Spring Framework 参考文档

作者

Rod Johnson, Juergen Hoeller, Keith Donald, Colin Sampaleanu, Rob Harrop, Thomas Risberg, Alef Arendsen, Darren Davison, Dmitriy Kopylenko, Mark Pollack, Thierry Templier, Erwin Vervaet, Portia Tung, Ben Hale, Adrian Colyer, John Lewis, Costin Leau, Mark Fisher, Sam Brannen, Ramnivas Laddad, Arjen Poutsma, Chris Beams, Tareq Abedrabbo, Andy Clement, Dave Syer, Oliver Gierke, Rossen Stoyanchev, Phillip Webb, Rob Winch, Brian Clozel, Stephane Nicoll, Sebastien Deleuze

翻译

Aaron    Email:   pengjieran@gmail.com

4.3.4.RELEASE

Copyright © 2004-2016

Copies of this document may be made for your own use and for distribution to others, provided that you do not charge any fee for such copies and further provided that each copy contains this Copyright Notice, whether distributed in print or electronically.

文档目录

I. Spring Framework概述
1. Spring入门
2. Spring Framework简介
2.1. DI和IOC
2.2. 模块
2.2.1. 核心容器
2.2.2. AOP and Instrumentation
2.2.3. Messaging
2.2.4. Data Access/Integration
2.2.5. Web
2.2.6. Test
2.3. Usage scenarios
2.3.1. Dependency Management and Naming Conventions
Spring Dependencies and Depending on Spring
Maven Dependency Management
Maven "Bill Of Materials" Dependency
Gradle Dependency Management
Ivy Dependency Management
Distribution Zip Files
2.3.2. Logging
Not Using Commons Logging
Using SLF4J
Using Log4J
II. What’s New in Spring Framework 4.x
3. New Features and Enhancements in Spring Framework 4.0
3.1. Improved Getting Started Experience
3.2. Removed Deprecated Packages and Methods
3.3. Java 8 (as well as 6 and 7)
3.4. Java EE 6 and 7
3.5. Groovy Bean Definition DSL
3.6. Core Container Improvements
3.7. General Web Improvements
3.8. WebSocket, SockJS, and STOMP Messaging
3.9. Testing Improvements
4. New Features and Enhancements in Spring Framework 4.1
4.1. JMS Improvements
4.2. Caching Improvements
4.3. Web Improvements
4.4. WebSocket Messaging Improvements
4.5. Testing Improvements
5. New Features and Enhancements in Spring Framework 4.2
5.1. Core Container Improvements
5.2. Data Access Improvements
5.3. JMS Improvements
5.4. Web Improvements
5.5. WebSocket Messaging Improvements
5.6. Testing Improvements
6. New Features and Enhancements in Spring Framework 4.3
6.1. Core Container Improvements
6.2. Data Access Improvements
6.3. Caching Improvements
6.4. JMS Improvements
6.5. Web Improvements
6.6. WebSocket Messaging Improvements
6.7. Testing Improvements
6.8. Support for new library and server generations
III. Core Technologies
7. The IoC container
7.1. Introduction to the Spring IoC container and beans
7.2. Container overview
7.2.1. Configuration metadata
7.2.2. Instantiating a container
Composing XML-based configuration metadata
7.2.3. Using the container
7.3. Bean overview
7.3.1. Naming beans
Aliasing a bean outside the bean definition
7.3.2. Instantiating beans
Instantiation with a constructor
Instantiation with a static factory method
Instantiation using an instance factory method
7.4. Dependencies
7.4.1. Dependency Injection
Constructor-based dependency injection
Setter-based dependency injection
Dependency resolution process
Examples of dependency injection
7.4.2. Dependencies and configuration in detail
Straight values (primitives, Strings, and so on)
References to other beans (collaborators)
Inner beans
Collections
Null and empty string values
XML shortcut with the p-namespace
XML shortcut with the c-namespace
Compound property names
7.4.3. Using depends-on
7.4.4. Lazy-initialized beans
7.4.5. Autowiring collaborators
Limitations and disadvantages of autowiring
Excluding a bean from autowiring
7.4.6. Method injection
Lookup method injection
Arbitrary method replacement
7.5. Bean scopes
7.5.1. The singleton scope
7.5.2. The prototype scope
7.5.3. Singleton beans with prototype-bean dependencies
7.5.4. Request, session, global session, application, and WebSocket scopes
Initial web configuration
Request scope
Session scope
Global session scope
Application scope
Scoped beans as dependencies
7.5.5. Custom scopes
Creating a custom scope
Using a custom scope
7.6. Customizing the nature of a bean
7.6.1. Lifecycle callbacks
Initialization callbacks
Destruction callbacks
Default initialization and destroy methods
Combining lifecycle mechanisms
Startup and shutdown callbacks
Shutting down the Spring IoC container gracefully in non-web applications
7.6.2. ApplicationContextAware and BeanNameAware
7.6.3. Other Aware interfaces
7.7. Bean definition inheritance
7.8. Container Extension Points
7.8.1. Customizing beans using a BeanPostProcessor
Example: Hello World, BeanPostProcessor-style
Example: The RequiredAnnotationBeanPostProcessor
7.8.2. Customizing configuration metadata with a BeanFactoryPostProcessor
Example: the Class name substitution PropertyPlaceholderConfigurer
Example: the PropertyOverrideConfigurer
7.8.3. Customizing instantiation logic with a FactoryBean
7.9. Annotation-based container configuration
7.9.1. @Required
7.9.2. @Autowired
7.9.3. Fine-tuning annotation-based autowiring with @Primary
7.9.4. Fine-tuning annotation-based autowiring with qualifiers
7.9.5. Using generics as autowiring qualifiers
7.9.6. CustomAutowireConfigurer
7.9.7. @Resource
7.9.8. @PostConstruct and @PreDestroy
7.10. Classpath scanning and managed components
7.10.1. @Component and further stereotype annotations
7.10.2. Meta-annotations
7.10.3. Automatically detecting classes and registering bean definitions
7.10.4. Using filters to customize scanning
7.10.5. Defining bean metadata within components
7.10.6. Naming autodetected components
7.10.7. Providing a scope for autodetected components
7.10.8. Providing qualifier metadata with annotations
7.11. Using JSR 330 Standard Annotations
7.11.1. Dependency Injection with @Inject and @Named
7.11.2. @Named and @ManagedBean: standard equivalents to the @Component annotation
7.11.3. Limitations of JSR-330 standard annotations
7.12. Java-based container configuration
7.12.1. Basic concepts: @Bean and @Configuration
7.12.2. Instantiating the Spring container using AnnotationConfigApplicationContext
Simple construction
Building the container programmatically using register(Class<?>…​)
Enabling component scanning with scan(String…​)
Support for web applications with AnnotationConfigWebApplicationContext
7.12.3. Using the @Bean annotation
Declaring a bean
Bean dependencies
Receiving lifecycle callbacks
Specifying bean scope
Customizing bean naming
Bean aliasing
Bean description
7.12.4. Using the @Configuration annotation
Injecting inter-bean dependencies
Lookup method injection
Further information about how Java-based configuration works internally
7.12.5. Composing Java-based configurations
Using the @Import annotation
Conditionally include @Configuration classes or @Bean methods
Combining Java and XML configuration
7.13. Environment abstraction
7.13.1. Bean definition profiles
@Profile
7.13.2. XML bean definition profiles
Activating a profile
Default profile
7.13.3. PropertySource abstraction
7.13.4. @PropertySource
7.13.5. Placeholder resolution in statements
7.14. Registering a LoadTimeWeaver
7.15. Additional Capabilities of the ApplicationContext
7.15.1. Internationalization using MessageSource
7.15.2. Standard and Custom Events
Annotation-based Event Listeners
Asynchronous Listeners
Ordering Listeners
Generic Events
7.15.3. Convenient access to low-level resources
7.15.4. Convenient ApplicationContext instantiation for web applications
7.15.5. Deploying a Spring ApplicationContext as a Java EE RAR file
7.16. The BeanFactory
7.16.1. BeanFactory or ApplicationContext?
7.16.2. Glue code and the evil singleton
8. Resources
8.1. Introduction
8.2. The Resource interface
8.3. Built-in Resource implementations
8.3.1. UrlResource
8.3.2. ClassPathResource
8.3.3. FileSystemResource
8.3.4. ServletContextResource
8.3.5. InputStreamResource
8.3.6. ByteArrayResource
8.4. The ResourceLoader
8.5. The ResourceLoaderAware interface
8.6. Resources as dependencies
8.7. Application contexts and Resource paths
8.7.1. Constructing application contexts
Constructing ClassPathXmlApplicationContext instances - shortcuts
8.7.2. Wildcards in application context constructor resource paths
Ant-style Patterns
The Classpath*: portability classpath*: prefix
Other notes relating to wildcards
8.7.3. FileSystemResource caveats
9. Validation, Data Binding, and Type Conversion
9.1. Introduction
9.2. Validation using Spring’s Validator interface
9.3. Resolving codes to error messages
9.4. Bean manipulation and the BeanWrapper
9.4.1. Setting and getting basic and nested properties
9.4.2. Built-in PropertyEditor implementations
Registering additional custom PropertyEditors
9.5. Spring Type Conversion
9.5.1. Converter SPI
9.5.2. ConverterFactory
9.5.3. GenericConverter
ConditionalGenericConverter
9.5.4. ConversionService API
9.5.5. Configuring a ConversionService
9.5.6. Using a ConversionService programmatically
9.6. Spring Field Formatting
9.6.1. Formatter SPI
9.6.2. Annotation-driven Formatting
Format Annotation API
9.6.3. FormatterRegistry SPI
9.6.4. FormatterRegistrar SPI
9.6.5. Configuring Formatting in Spring MVC
9.7. Configuring a global date & time format
9.8. Spring Validation
9.8.1. Overview of the JSR-303 Bean Validation API
9.8.2. Configuring a Bean Validation Provider
Injecting a Validator
Configuring Custom Constraints
Spring-driven Method Validation
Additional Configuration Options
9.8.3. Configuring a DataBinder
9.8.4. Spring MVC 3 Validation
10. Spring Expression Language (SpEL)
10.1. Introduction
10.2. Feature Overview
10.3. Expression Evaluation using Spring’s Expression Interface
10.3.1. The EvaluationContext interface
Type Conversion
10.3.2. Parser configuration
10.3.3. SpEL compilation
Compiler configuration
Compiler limitations
10.4. Expression support for defining bean definitions
10.4.1. XML based configuration
10.4.2. Annotation-based configuration
10.5. Language Reference
10.5.1. Literal expressions
10.5.2. Properties, Arrays, Lists, Maps, Indexers
10.5.3. Inline lists
10.5.4. Inline Maps
10.5.5. Array construction
10.5.6. Methods
10.5.7. Operators
Relational operators
Logical operators
Mathematical operators
10.5.8. Assignment
10.5.9. Types
10.5.10. Constructors
10.5.11. Variables
The #this and #root variables
10.5.12. Functions
10.5.13. Bean references
10.5.14. Ternary Operator (If-Then-Else)
10.5.15. The Elvis Operator
10.5.16. Safe Navigation operator
10.5.17. Collection Selection
10.5.18. Collection Projection
10.5.19. Expression templating
10.6. Classes used in the examples
11. Aspect Oriented Programming with Spring
11.1. Introduction
11.1.1. AOP concepts
11.1.2. Spring AOP capabilities and goals
11.1.3. AOP Proxies
11.2. @AspectJ support
11.2.1. Enabling @AspectJ Support
Enabling @AspectJ Support with Java configuration
Enabling @AspectJ Support with XML configuration
11.2.2. Declaring an aspect
11.2.3. Declaring a pointcut
Supported Pointcut Designators
Combining pointcut expressions
Sharing common pointcut definitions
Examples
Writing good pointcuts
11.2.4. Declaring advice
Before advice
After returning advice
After throwing advice
After (finally) advice
Around advice
Advice parameters
Advice ordering
11.2.5. Introductions
11.2.6. Aspect instantiation models
11.2.7. Example
11.3. Schema-based AOP support
11.3.1. Declaring an aspect
11.3.2. Declaring a pointcut
11.3.3. Declaring advice
Before advice
After returning advice
After throwing advice
After (finally) advice
Around advice
Advice parameters
Advice ordering
11.3.4. Introductions
11.3.5. Aspect instantiation models
11.3.6. Advisors
11.3.7. Example
11.4. Choosing which AOP declaration style to use
11.4.1. Spring AOP or full AspectJ?
11.4.2. @AspectJ or XML for Spring AOP?
11.5. Mixing aspect types
11.6. Proxying mechanisms
11.6.1. Understanding AOP proxies
11.7. Programmatic creation of @AspectJ Proxies
11.8. Using AspectJ with Spring applications
11.8.1. Using AspectJ to dependency inject domain objects with Spring
Unit testing @Configurable objects
Working with multiple application contexts
11.8.2. Other Spring aspects for AspectJ
11.8.3. Configuring AspectJ aspects using Spring IoC
11.8.4. Load-time weaving with AspectJ in the Spring Framework
A first example
Aspects
'META-INF/aop.xml'
Required libraries (JARS)
Spring configuration
Environment-specific configuration
11.9. Further Resources
12. Spring AOP APIs
12.1. Introduction
12.2. Pointcut API in Spring
12.2.1. Concepts
12.2.2. Operations on pointcuts
12.2.3. AspectJ expression pointcuts
12.2.4. Convenience pointcut implementations
Static pointcuts
Dynamic pointcuts
12.2.5. Pointcut superclasses
12.2.6. Custom pointcuts
12.3. Advice API in Spring
12.3.1. Advice lifecycles
12.3.2. Advice types in Spring
Interception around advice
Before advice
Throws advice
After Returning advice
Introduction advice
12.4. Advisor API in Spring
12.5. Using the ProxyFactoryBean to create AOP proxies
12.5.1. Basics
12.5.2. JavaBean properties
12.5.3. JDK- and CGLIB-based proxies
12.5.4. Proxying interfaces
12.5.5. Proxying classes
12.5.6. Using 'global' advisors
12.6. Concise proxy definitions
12.7. Creating AOP proxies programmatically with the ProxyFactory
12.8. Manipulating advised objects
12.9. Using the "auto-proxy" facility
12.9.1. Autoproxy bean definitions
BeanNameAutoProxyCreator
DefaultAdvisorAutoProxyCreator
AbstractAdvisorAutoProxyCreator
12.9.2. Using metadata-driven auto-proxying
12.10. Using TargetSources
12.10.1. Hot swappable target sources
12.10.2. Pooling target sources
12.10.3. Prototype target sources
12.10.4. ThreadLocal target sources
12.11. Defining new Advice types
12.12. Further resources
IV. Testing
13. Introduction to Spring Testing
14. Unit Testing
14.1. Mock Objects
14.1.1. Environment
14.1.2. JNDI
14.1.3. Servlet API
14.1.4. Portlet API
14.2. Unit Testing support Classes
14.2.1. General testing utilities
14.2.2. Spring MVC
15. Integration Testing
15.1. Overview
15.2. Goals of Integration Testing
15.2.1. Context management and caching
15.2.2. Dependency Injection of test fixtures
15.2.3. Transaction management
15.2.4. Support classes for integration testing
15.3. JDBC Testing Support
15.4. Annotations
15.4.1. Spring Testing Annotations
@BootstrapWith
@ContextConfiguration
@WebAppConfiguration
@ContextHierarchy
@ActiveProfiles
@TestPropertySource
@DirtiesContext
@TestExecutionListeners
@Commit
@Rollback
@BeforeTransaction
@AfterTransaction
@Sql
@SqlConfig
@SqlGroup
15.4.2. Standard Annotation Support
15.4.3. Spring JUnit 4 Testing Annotations
@IfProfileValue
@ProfileValueSourceConfiguration
@Timed
@Repeat
15.4.4. Meta-Annotation Support for Testing
15.5. Spring TestContext Framework
15.5.1. Key abstractions
TestContext
TestContextManager
TestExecutionListener
Context Loaders
15.5.2. Bootstrapping the TestContext framework
15.5.3. TestExecutionListener configuration
Registering custom TestExecutionListeners
Automatic discovery of default TestExecutionListeners
Ordering TestExecutionListeners
Merging TestExecutionListeners
15.5.4. Context management
Context configuration with XML resources
Context configuration with Groovy scripts
Context configuration with annotated classes
Mixing XML, Groovy scripts, and annotated classes
Context configuration with context initializers
Context configuration inheritance
Context configuration with environment profiles
Context configuration with test property sources
Loading a WebApplicationContext
Context caching
Context hierarchies
15.5.5. Dependency injection of test fixtures
15.5.6. Testing request and session scoped beans
15.5.7. Transaction management
Test-managed transactions
Enabling and disabling transactions
Transaction rollback and commit behavior
Programmatic transaction management
Executing code outside of a transaction
Configuring a transaction manager
Demonstration of all transaction-related annotations
15.5.8. Executing SQL scripts
Executing SQL scripts programmatically
Executing SQL scripts declaratively with @Sql
15.5.9. TestContext Framework support classes
Spring JUnit 4 Runner
Spring JUnit 4 Rules
JUnit 4 support classes
TestNG support classes
15.6. Spring MVC Test Framework
15.6.1. Server-Side Tests
Static Imports
Setup Options
Performing Requests
Defining Expectations
Filter Registrations
Differences between Out-of-Container and End-to-End Integration Tests
Further Server-Side Test Examples
15.6.2. HtmlUnit Integration
Why HtmlUnit Integration?
MockMvc and HtmlUnit
MockMvc and WebDriver
MockMvc and Geb
15.6.3. Client-Side REST Tests
Static Imports
Further Examples of Client-side REST Tests
15.7. PetClinic Example
16. Further Resources
V. Data Access
17. Transaction Management
17.1. Introduction to Spring Framework transaction management
17.2. Advantages of the Spring Framework’s transaction support model
17.2.1. Global transactions
17.2.2. Local transactions
17.2.3. Spring Framework’s consistent programming model
17.3. Understanding the Spring Framework transaction abstraction
17.4. Synchronizing resources with transactions
17.4.1. High-level synchronization approach
17.4.2. Low-level synchronization approach
17.4.3. TransactionAwareDataSourceProxy
17.5. Declarative transaction management
17.5.1. Understanding the Spring Framework’s declarative transaction implementation
17.5.2. Example of declarative transaction implementation
17.5.3. Rolling back a declarative transaction
17.5.4. Configuring different transactional semantics for different beans
17.5.5. <tx:advice/> settings
17.5.6. Using @Transactional
@Transactional settings
Multiple Transaction Managers with @Transactional
Custom shortcut annotations
17.5.7. Transaction propagation
Required
RequiresNew
Nested
17.5.8. Advising transactional operations
17.5.9. Using @Transactional with AspectJ
17.6. Programmatic transaction management
17.6.1. Using the TransactionTemplate
Specifying transaction settings
17.6.2. Using the PlatformTransactionManager
17.7. Choosing between programmatic and declarative transaction management
17.8. Transaction bound event
17.9. Application server-specific integration
17.9.1. IBM WebSphere
17.9.2. Oracle WebLogic Server
17.10. Solutions to common problems
17.10.1. Use of the wrong transaction manager for a specific DataSource
17.11. Further Resources
18. DAO support
18.1. Introduction
18.2. Consistent exception hierarchy
18.3. Annotations used for configuring DAO or Repository classes
19. Data access with JDBC
19.1. Introduction to Spring Framework JDBC
19.1.1. Choosing an approach for JDBC database access
19.1.2. Package hierarchy
19.2. Using the JDBC core classes to control basic JDBC processing and error handling
19.2.1. JdbcTemplate
Examples of JdbcTemplate class usage
JdbcTemplate best practices
19.2.2. NamedParameterJdbcTemplate
19.2.3. SQLExceptionTranslator
19.2.4. Executing statements
19.2.5. Running queries
19.2.6. Updating the database
19.2.7. Retrieving auto-generated keys
19.3. Controlling database connections
19.3.1. DataSource
19.3.2. DataSourceUtils
19.3.3. SmartDataSource
19.3.4. AbstractDataSource
19.3.5. SingleConnectionDataSource
19.3.6. DriverManagerDataSource
19.3.7. TransactionAwareDataSourceProxy
19.3.8. DataSourceTransactionManager
19.3.9. NativeJdbcExtractor
19.4. JDBC batch operations
19.4.1. Basic batch operations with the JdbcTemplate
19.4.2. Batch operations with a List of objects
19.4.3. Batch operations with multiple batches
19.5. Simplifying JDBC operations with the SimpleJdbc classes
19.5.1. Inserting data using SimpleJdbcInsert
19.5.2. Retrieving auto-generated keys using SimpleJdbcInsert
19.5.3. Specifying columns for a SimpleJdbcInsert
19.5.4. Using SqlParameterSource to provide parameter values
19.5.5. Calling a stored procedure with SimpleJdbcCall
19.5.6. Explicitly declaring parameters to use for a SimpleJdbcCall
19.5.7. How to define SqlParameters
19.5.8. Calling a stored function using SimpleJdbcCall
19.5.9. Returning ResultSet/REF Cursor from a SimpleJdbcCall
19.6. Modeling JDBC operations as Java objects
19.6.1. SqlQuery
19.6.2. MappingSqlQuery
19.6.3. SqlUpdate
19.6.4. StoredProcedure
19.7. Common problems with parameter and data value handling
19.7.1. Providing SQL type information for parameters
19.7.2. Handling BLOB and CLOB objects
19.7.3. Passing in lists of values for IN clause
19.7.4. Handling complex types for stored procedure calls
19.8. Embedded database support
19.8.1. Why use an embedded database?
19.8.2. Creating an embedded database using Spring XML
19.8.3. Creating an embedded database programmatically
19.8.4. Selecting the embedded database type
Using HSQL
Using H2
Using Derby
19.8.5. Testing data access logic with an embedded database
19.8.6. Generating unique names for embedded databases
19.8.7. Extending the embedded database support
19.9. Initializing a DataSource
19.9.1. Initializing a database using Spring XML
Initialization of other components that depend on the database
20. Object Relational Mapping (ORM) Data Access
20.1. Introduction to ORM with Spring
20.2. General ORM integration considerations
20.2.1. Resource and transaction management
20.2.2. Exception translation
20.3. Hibernate
20.3.1. SessionFactory setup in a Spring container
20.3.2. Implementing DAOs based on plain Hibernate API
20.3.3. Declarative transaction demarcation
20.3.4. Programmatic transaction demarcation
20.3.5. Transaction management strategies
20.3.6. Comparing container-managed and locally defined resources
20.3.7. Spurious application server warnings with Hibernate
20.4. JDO
20.4.1. PersistenceManagerFactory setup
20.4.2. Implementing DAOs based on the plain JDO API
20.4.3. Transaction management
20.4.4. JdoDialect
20.5. JPA
20.5.1. Three options for JPA setup in a Spring environment
LocalEntityManagerFactoryBean
Obtaining an EntityManagerFactory from JNDI
LocalContainerEntityManagerFactoryBean
Dealing with multiple persistence units
20.5.2. Implementing DAOs based on plain JPA
20.5.3. Transaction Management
20.5.4. JpaDialect
21. Marshalling XML using O/X Mappers
21.1. Introduction
21.1.1. Ease of configuration
21.1.2. Consistent Interfaces
21.1.3. Consistent Exception Hierarchy
21.2. Marshaller and Unmarshaller
21.2.1. Marshaller
21.2.2. Unmarshaller
21.2.3. XmlMappingException
21.3. Using Marshaller and Unmarshaller
21.4. XML Schema-based Configuration
21.5. JAXB
21.5.1. Jaxb2Marshaller
XML Schema-based Configuration
21.6. Castor
21.6.1. CastorMarshaller
21.6.2. Mapping
XML Schema-based Configuration
21.7. XMLBeans
21.7.1. XmlBeansMarshaller
XML Schema-based Configuration
21.8. JiBX
21.8.1. JibxMarshaller
XML Schema-based Configuration
21.9. XStream
21.9.1. XStreamMarshaller
VI. The Web
22. Web MVC framework
22.1. Introduction to Spring Web MVC framework
22.1.1. Features of Spring Web MVC
22.1.2. Pluggability of other MVC implementations
22.2. The DispatcherServlet
22.2.1. Special Bean Types In the WebApplicationContext
22.2.2. Default DispatcherServlet Configuration
22.2.3. DispatcherServlet Processing Sequence
22.3. Implementing Controllers
22.3.1. Defining a controller with @Controller
22.3.2. Mapping Requests With @RequestMapping
Composed @RequestMapping Variants
@Controller and AOP Proxying
New Support Classes for @RequestMapping methods in Spring MVC 3.1
URI Template Patterns
URI Template Patterns with Regular Expressions
Path Patterns
Path Pattern Comparison
Path Patterns with Placeholders
Suffix Pattern Matching
Suffix Pattern Matching and RFD
Matrix Variables
Consumable Media Types
Producible Media Types
Request Parameters and Header Values
HTTP HEAD and HTTP OPTIONS
22.3.3. Defining @RequestMapping handler methods
Supported method argument types
Supported method return types
Binding request parameters to method parameters with @RequestParam
Mapping the request body with the @RequestBody annotation
Mapping the response body with the @ResponseBody annotation
Creating REST Controllers with the @RestController annotation
Using HttpEntity
Using @ModelAttribute on a method
Using @ModelAttribute on a method argument
Using @SessionAttributes to store model attributes in the HTTP session between requests
Using @SessionAttribute to access pre-existing global session attributes
Using @RequestAttribute to access request attributes
Working with "application/x-www-form-urlencoded" data
Mapping cookie values with the @CookieValue annotation
Mapping request header attributes with the @RequestHeader annotation
Method Parameters And Type Conversion
Customizing WebDataBinder initialization
Advising controllers with @ControllerAdvice and @RestControllerAdvice
Jackson Serialization View Support
Jackson JSONP Support
22.3.4. Asynchronous Request Processing
Exception Handling for Async Requests
Intercepting Async Requests
HTTP Streaming
HTTP Streaming With Server-Sent Events
HTTP Streaming Directly To The OutputStream
Configuring Asynchronous Request Processing
22.3.5. Testing Controllers
22.4. Handler mappings
22.4.1. Intercepting requests with a HandlerInterceptor
22.5. Resolving views
22.5.1. Resolving views with the ViewResolver interface
22.5.2. Chaining ViewResolvers
22.5.3. Redirecting to Views
RedirectView
The redirect: prefix
The forward: prefix
22.5.4. ContentNegotiatingViewResolver
22.6. Using flash attributes
22.7. Building URIs
22.7.1. Building URIs to Controllers and methods
22.7.2. Building URIs to Controllers and methods from views
22.8. Using locales
22.8.1. Obtaining Time Zone Information
22.8.2. AcceptHeaderLocaleResolver
22.8.3. CookieLocaleResolver
22.8.4. SessionLocaleResolver
22.8.5. LocaleChangeInterceptor
22.9. Using themes
22.9.1. Overview of themes
22.9.2. Defining themes
22.9.3. Theme resolvers
22.10. Spring’s multipart (file upload) support
22.10.1. Introduction
22.10.2. Using a MultipartResolver with Commons FileUpload
22.10.3. Using a MultipartResolver with Servlet 3.0
22.10.4. Handling a file upload in a form
22.10.5. Handling a file upload request from programmatic clients
22.11. Handling exceptions
22.11.1. HandlerExceptionResolver
22.11.2. @ExceptionHandler
22.11.3. Handling Standard Spring MVC Exceptions
22.11.4. Annotating Business Exceptions With @ResponseStatus
22.11.5. Customizing the Default Servlet Container Error Page
22.12. Web Security
22.13. Convention over configuration support
22.13.1. The Controller ControllerClassNameHandlerMapping
22.13.2. The Model ModelMap (ModelAndView)
22.13.3. The View - RequestToViewNameTranslator
22.14. HTTP caching support
22.14.1. Cache-Control HTTP header
22.14.2. HTTP caching support for static resources
22.14.3. Support for the Cache-Control, ETag and Last-Modified response headers in Controllers
22.14.4. Shallow ETag support
22.15. Code-based Servlet container initialization
22.16. Configuring Spring MVC
22.16.1. Enabling the MVC Java Config or the MVC XML Namespace
22.16.2. Customizing the Provided Configuration
22.16.3. Conversion and Formatting
22.16.4. Validation
22.16.5. Interceptors
22.16.6. Content Negotiation
22.16.7. View Controllers
22.16.8. View Resolvers
22.16.9. Serving of Resources
22.16.10. Falling Back On the "Default" Servlet To Serve Resources
22.16.11. Path Matching
22.16.12. Message Converters
22.16.13. Advanced Customizations with MVC Java Config
22.16.14. Advanced Customizations with the MVC Namespace
23. View technologies
23.1. Introduction
23.2. Thymeleaf
23.3. Groovy Markup Templates
23.3.1. Configuration
23.3.2. Example
23.4. Velocity & FreeMarker
23.4.1. Dependencies
23.4.2. Context configuration
23.4.3. Creating templates
23.4.4. Advanced configuration
velocity.properties
FreeMarker
23.4.5. Bind support and form handling
The bind macros
Simple binding
Form input generation macros
HTML escaping and XHTML compliance
23.5. JSP & JSTL
23.5.1. View resolvers
23.5.2. 'Plain-old' JSPs versus JSTL
23.5.3. Additional tags facilitating development
23.5.4. Using Spring’s form tag library
Configuration
The form tag
The input tag
The checkbox tag
The checkboxes tag
The radiobutton tag
The radiobuttons tag
The password tag
The select tag
The option tag
The options tag
The textarea tag
The hidden tag
The errors tag
HTTP Method Conversion
HTML5 Tags
23.6. Script templates
23.6.1. Dependencies
23.6.2. How to integrate script based templating
23.7. XML Marshalling View
23.8. Tiles
23.8.1. Dependencies
23.8.2. How to integrate Tiles
UrlBasedViewResolver
ResourceBundleViewResolver
SimpleSpringPreparerFactory and SpringBeanPreparerFactory
23.9. XSLT
23.9.1. My First Words
Bean definitions
Standard MVC controller code
Document transformation
23.10. Document views (PDF/Excel)
23.10.1. Introduction
23.10.2. Configuration and setup
Document view definitions
Controller code
Subclassing for Excel views
Subclassing for PDF views
23.11. JasperReports
23.11.1. Dependencies
23.11.2. Configuration
Configuring the ViewResolver
Configuring the Views
About Report Files
Using JasperReportsMultiFormatView
23.11.3. Populating the ModelAndView
23.11.4. Working with Sub-Reports
Configuring Sub-Report Files
Configuring Sub-Report Data Sources
23.11.5. Configuring Exporter Parameters
23.12. Feed Views
23.13. JSON Mapping View
23.14. XML Mapping View
24. Integrating with other web frameworks
24.1. Introduction
24.2. Common configuration
24.3. JavaServer Faces 1.2
24.3.1. SpringBeanFacesELResolver (JSF 1.2+)
24.3.2. FacesContextUtils
24.4. Apache Struts 2.x
24.5. Tapestry 5.x
24.6. Further Resources
25. Portlet MVC Framework
25.1. Introduction
25.1.1. Controllers - The C in MVC
25.1.2. Views - The V in MVC
25.1.3. Web-scoped beans
25.2. The DispatcherPortlet
25.3. The ViewRendererServlet
25.4. Controllers
25.4.1. AbstractController and PortletContentGenerator
25.4.2. Other simple controllers
25.4.3. Command Controllers
25.4.4. PortletWrappingController
25.5. Handler mappings
25.5.1. PortletModeHandlerMapping
25.5.2. ParameterHandlerMapping
25.5.3. PortletModeParameterHandlerMapping
25.5.4. Adding HandlerInterceptors
25.5.5. HandlerInterceptorAdapter
25.5.6. ParameterMappingInterceptor
25.6. Views and resolving them
25.7. Multipart (file upload) support
25.7.1. Using the PortletMultipartResolver
25.7.2. Handling a file upload in a form
25.8. Handling exceptions
25.9. Annotation-based controller configuration
25.9.1. Setting up the dispatcher for annotation support
25.9.2. Defining a controller with @Controller
25.9.3. Mapping requests with @RequestMapping
25.9.4. Supported handler method arguments
25.9.5. Binding request parameters to method parameters with @RequestParam
25.9.6. Providing a link to data from the model with @ModelAttribute
25.9.7. Specifying attributes to store in a Session with @SessionAttributes
25.9.8. Customizing WebDataBinder initialization
Customizing data binding with @InitBinder
Configuring a custom WebBindingInitializer
25.10. Portlet application deployment
26. WebSocket Support
26.1. Introduction
26.1.1. WebSocket Fallback Options
26.1.2. A Messaging Architecture
26.1.3. Sub-Protocol Support in WebSocket
26.1.4. Should I Use WebSocket?
26.2. WebSocket API
26.2.1. Create and Configure a WebSocketHandler
26.2.2. Customizing the WebSocket Handshake
26.2.3. WebSocketHandler Decoration
26.2.4. Deployment Considerations
26.2.5. Configuring the WebSocket Engine
26.2.6. Configuring allowed origins
26.3. SockJS Fallback Options
26.3.1. Overview of SockJS
26.3.2. Enable SockJS
26.3.3. HTTP Streaming in IE 8, 9: Ajax/XHR vs IFrame
26.3.4. Heartbeat Messages
26.3.5. Servlet 3 Async Requests
26.3.6. CORS Headers for SockJS
26.3.7. SockJS Client
26.4. STOMP Over WebSocket Messaging Architecture
26.4.1. Overview of STOMP
26.4.2. Enable STOMP over WebSocket
26.4.3. Flow of Messages
26.4.4. Annotation Message Handling
26.4.5. Sending Messages
26.4.6. Simple Broker
26.4.7. Full-Featured Broker
26.4.8. Connections To Full-Featured Broker
26.4.9. Using Dot as Separator in @MessageMapping Destinations
26.4.10. Authentication
26.4.11. User Destinations
26.4.12. Listening To ApplicationContext Events and Intercepting Messages
26.4.13. STOMP Client
26.4.14. WebSocket Scope
26.4.15. Configuration and Performance
26.4.16. Runtime Monitoring
26.4.17. Testing Annotated Controller Methods
27. CORS Support
27.1. Introduction
27.2. Controller method CORS configuration
27.3. Global CORS configuration
27.3.1. JavaConfig
27.3.2. XML namespace
27.4. Advanced Customization
27.5. Filter based CORS support
VII. Integration
28. Remoting and web services using Spring
28.1. Introduction
28.2. Exposing services using RMI
28.2.1. Exporting the service using the RmiServiceExporter
28.2.2. Linking in the service at the client
28.3. Using Hessian or Burlap to remotely call services via HTTP
28.3.1. Wiring up the DispatcherServlet for Hessian and co.
28.3.2. Exposing your beans by using the HessianServiceExporter
28.3.3. Linking in the service on the client
28.3.4. Using Burlap
28.3.5. Applying HTTP basic authentication to a service exposed through Hessian or Burlap
28.4. Exposing services using HTTP invokers
28.4.1. Exposing the service object
28.4.2. Linking in the service at the client
28.5. Web services
28.5.1. Exposing servlet-based web services using JAX-WS
28.5.2. Exporting standalone web services using JAX-WS
28.5.3. Exporting web services using the JAX-WS RI’s Spring support
28.5.4. Accessing web services using JAX-WS
28.6. JMS
28.6.1. Server-side configuration
28.6.2. Client-side configuration
28.7. AMQP
28.8. Auto-detection is not implemented for remote interfaces
28.9. Considerations when choosing a technology
28.10. Accessing RESTful services on the Client
28.10.1. RestTemplate
Working with the URI
Dealing with request and response headers
Jackson JSON Views support
28.10.2. HTTP Message Conversion
StringHttpMessageConverter
FormHttpMessageConverter
ByteArrayHttpMessageConverter
MarshallingHttpMessageConverter
MappingJackson2HttpMessageConverter
MappingJackson2XmlHttpMessageConverter
SourceHttpMessageConverter
BufferedImageHttpMessageConverter
28.10.3. Async RestTemplate
29. Enterprise JavaBeans (EJB) integration
29.1. Introduction
29.2. Accessing EJBs
29.2.1. Concepts
29.2.2. Accessing local SLSBs
29.2.3. Accessing remote SLSBs
29.2.4. Accessing EJB 2.x SLSBs versus EJB 3 SLSBs
29.3. Using Spring’s EJB implementation support classes
29.3.1. EJB 3 injection interceptor
30. JMS (Java Message Service)
30.1. Introduction
30.2. Using Spring JMS
30.2.1. JmsTemplate
30.2.2. Connections
Caching Messaging Resources
SingleConnectionFactory
CachingConnectionFactory
30.2.3. Destination Management
30.2.4. Message Listener Containers
SimpleMessageListenerContainer
DefaultMessageListenerContainer
30.2.5. Transaction management
30.3. Sending a Message
30.3.1. Using Message Converters
30.3.2. SessionCallback and ProducerCallback
30.4. Receiving a message
30.4.1. Synchronous Reception
30.4.2. Asynchronous Reception - Message-Driven POJOs
30.4.3. the SessionAwareMessageListener interface
30.4.4. the MessageListenerAdapter
30.4.5. Processing messages within transactions
30.5. Support for JCA Message Endpoints
30.6. Annotation-driven listener endpoints
30.6.1. Enable listener endpoint annotations
30.6.2. Programmatic endpoints registration
30.6.3. Annotated endpoint method signature
30.6.4. Response management
30.7. JMS namespace support
31. JMX
31.1. Introduction
31.2. Exporting your beans to JMX
31.2.1. Creating an MBeanServer
31.2.2. Reusing an existing MBeanServer
31.2.3. Lazy-initialized MBeans
31.2.4. Automatic registration of MBeans
31.2.5. Controlling the registration behavior
31.3. Controlling the management interface of your beans
31.3.1. the MBeanInfoAssembler Interface
31.3.2. Using Source-Level Metadata (Java annotations)
31.3.3. Source-Level Metadata Types
31.3.4. the AutodetectCapableMBeanInfoAssembler interface
31.3.5. Defining management interfaces using Java interfaces
31.3.6. Using MethodNameBasedMBeanInfoAssembler
31.4. Controlling the ObjectNames for your beans
31.4.1. Reading ObjectNames from Properties
31.4.2. Using the MetadataNamingStrategy
31.4.3. Configuring annotation based MBean export
31.5. JSR-160 Connectors
31.5.1. Server-side Connectors
31.5.2. Client-side Connectors
31.5.3. JMX over Burlap/Hessian/SOAP
31.6. Accessing MBeans via Proxies
31.7. Notifications
31.7.1. Registering Listeners for Notifications
31.7.2. Publishing Notifications
31.8. Further Resources
32. JCA CCI
32.1. Introduction
32.2. Configuring CCI
32.2.1. Connector configuration
32.2.2. ConnectionFactory configuration in Spring
32.2.3. Configuring CCI connections
32.2.4. Using a single CCI connection
32.3. Using Spring’s CCI access support
32.3.1. Record conversion
32.3.2. the CciTemplate
32.3.3. DAO support
32.3.4. Automatic output record generation
32.3.5. Summary
32.3.6. Using a CCI Connection and Interaction directly
32.3.7. Example for CciTemplate usage
32.4. Modeling CCI access as operation objects
32.4.1. MappingRecordOperation
32.4.2. MappingCommAreaOperation
32.4.3. Automatic output record generation
32.4.4. Summary
32.4.5. Example for MappingRecordOperation usage
32.4.6. Example for MappingCommAreaOperation usage
32.5. Transactions
33. Email
33.1. Introduction
33.2. Usage
33.2.1. Basic MailSender and SimpleMailMessage usage
33.2.2. Using the JavaMailSender and the MimeMessagePreparator
33.3. Using the JavaMail MimeMessageHelper
33.3.1. Sending attachments and inline resources
Attachments
Inline resources
33.3.2. Creating email content using a templating library
A Velocity-based example
34. Task Execution and Scheduling
34.1. Introduction
34.2. The Spring TaskExecutor abstraction
34.2.1. TaskExecutor types
34.2.2. Using a TaskExecutor
34.3. The Spring TaskScheduler abstraction
34.3.1. the Trigger interface
34.3.2. Trigger implementations
34.3.3. TaskScheduler implementations
34.4. Annotation Support for Scheduling and Asynchronous Execution
34.4.1. Enable scheduling annotations
34.4.2. The @Scheduled annotation
34.4.3. The @Async annotation
34.4.4. Executor qualification with @Async
34.4.5. Exception management with @Async
34.5. The task namespace
34.5.1. The 'scheduler' element
34.5.2. The 'executor' element
34.5.3. The 'scheduled-tasks' element
34.6. Using the Quartz Scheduler
34.6.1. Using the JobDetailFactoryBean
34.6.2. Using the MethodInvokingJobDetailFactoryBean
34.6.3. Wiring up jobs using triggers and the SchedulerFactoryBean
35. Dynamic language support
35.1. Introduction
35.2. A first example
35.3. Defining beans that are backed by dynamic languages
35.3.1. Common concepts
The <lang:language/> element
Refreshable beans
Inline dynamic language source files
Understanding Constructor Injection in the context of dynamic-language-backed beans
35.3.2. JRuby beans
35.3.3. Groovy beans
Customizing Groovy objects via a callback
35.3.4. BeanShell beans
35.4. Scenarios
35.4.1. Scripted Spring MVC Controllers
35.4.2. Scripted Validators
35.5. Bits and bobs
35.5.1. AOP - advising scripted beans
35.5.2. Scoping
35.6. Further Resources
36. Cache Abstraction
36.1. Introduction
36.2. Understanding the cache abstraction
36.3. Declarative annotation-based caching
36.3.1. @Cacheable annotation
Default Key Generation
Custom Key Generation Declaration
Default Cache Resolution
Custom cache resolution
Synchronized caching
Conditional caching
Available caching SpEL evaluation context
36.3.2. @CachePut annotation
36.3.3. @CacheEvict annotation
36.3.4. @Caching annotation
36.3.5. @CacheConfig annotation
36.3.6. Enable caching annotations
36.3.7. Using custom annotations
36.4. JCache (JSR-107) annotations
36.4.1. Features summary
36.4.2. Enabling JSR-107 support
36.5. Declarative XML-based caching
36.6. Configuring the cache storage
36.6.1. JDK ConcurrentMap-based Cache
36.6.2. Ehcache-based Cache
36.6.3. Caffeine Cache
36.6.4. Guava Cache
36.6.5. GemFire-based Cache
36.6.6. JSR-107 Cache
36.6.7. Dealing with caches without a backing store
36.7. Plugging-in different back-end caches
36.8. How can I set the TTL/TTI/Eviction policy/XXX feature?
VIII. Appendices
37. Migrating to Spring Framework 4.x
38. Spring Annotation Programming Model
39. Classic Spring Usage
39.1. Classic ORM usage
39.1.1. Hibernate
The HibernateTemplate
Implementing Spring-based DAOs without callbacks
39.2. JMS Usage
39.2.1. JmsTemplate
39.2.2. Asynchronous Message Reception
39.2.3. Connections
39.2.4. Transaction Management
40. Classic Spring AOP Usage
40.1. Pointcut API in Spring
40.1.1. Concepts
40.1.2. Operations on pointcuts
40.1.3. AspectJ expression pointcuts
40.1.4. Convenience pointcut implementations
Static pointcuts
Dynamic pointcuts
40.1.5. Pointcut superclasses
40.1.6. Custom pointcuts
40.2. Advice API in Spring
40.2.1. Advice lifecycles
40.2.2. Advice types in Spring
Interception around advice
Before advice
Throws advice
After Returning advice
Introduction advice
40.3. Advisor API in Spring
40.4. Using the ProxyFactoryBean to create AOP proxies
40.4.1. Basics
40.4.2. JavaBean properties
40.4.3. JDK- and CGLIB-based proxies
40.4.4. Proxying interfaces
40.4.5. Proxying classes
40.4.6. Using 'global' advisors
40.5. Concise proxy definitions
40.6. Creating AOP proxies programmatically with the ProxyFactory
40.7. Manipulating advised objects
40.8. Using the "autoproxy" facility
40.8.1. Autoproxy bean definitions
BeanNameAutoProxyCreator
DefaultAdvisorAutoProxyCreator
AbstractAdvisorAutoProxyCreator
40.8.2. Using metadata-driven auto-proxying
40.9. Using TargetSources
40.9.1. Hot swappable target sources
40.9.2. Pooling target sources
40.9.3. Prototype target sources
40.9.4. ThreadLocal target sources
40.10. Defining new Advice types
40.11. Further resources
41. XML Schema-based configuration
41.1. Introduction
41.2. XML Schema-based configuration
41.2.1. Referencing the schemas
41.2.2. the util schema
<util:constant/>
<util:property-path/>
<util:properties/>
<util:list/>
<util:map/>
<util:set/>
41.2.3. the jee schema
<jee:jndi-lookup/> (simple)
<jee:jndi-lookup/> (with single JNDI environment setting)
<jee:jndi-lookup/> (with multiple JNDI environment settings)
<jee:jndi-lookup/> (complex)
<jee:local-slsb/> (simple)
<jee:local-slsb/> (complex)
<jee:remote-slsb/>
41.2.4. the lang schema
41.2.5. the jms schema
41.2.6. the tx (transaction) schema
41.2.7. the aop schema
41.2.8. the context schema
<property-placeholder/>
<annotation-config/>
<component-scan/>
<load-time-weaver/>
<spring-configured/>
<mbean-export/>
41.2.9. the tool schema
41.2.10. the jdbc schema
41.2.11. the cache schema
41.2.12. the beans schema
42. Extensible XML authoring
42.1. Introduction
42.2. Authoring the schema
42.3. Coding a NamespaceHandler
42.4. BeanDefinitionParser
42.5. Registering the handler and the schema
42.5.1. 'META-INF/spring.handlers'
42.5.2. 'META-INF/spring.schemas'
42.6. Using a custom extension in your Spring XML configuration
42.7. Meatier examples
42.7.1. Nesting custom tags within custom tags
42.7.2. Custom attributes on 'normal' elements
42.8. Further Resources
43. spring JSP Tag Library
43.1. Introduction
43.2. The argument tag
43.3. The bind tag
43.4. The escapeBody tag
43.5. The eval tag
43.6. The hasBindErrors tag
43.7. The htmlEscape tag
43.8. The message tag
43.9. The nestedPath tag
43.10. The param tag
43.11. The theme tag
43.12. The transform tag
43.13. The url tag
44. spring-form JSP Tag Library
44.1. Introduction
44.2. The button tag
44.3. The checkbox tag
44.4. The checkboxes tag
44.5. The errors tag
44.6. The form tag
44.7. The hidden tag
44.8. The input tag
44.9. The label tag
44.10. The option tag
44.11. The options tag
44.12. The password tag
44.13. The radiobutton tag
44.14. The radiobuttons tag
44.15. The select tag
44.16. The textarea tag

Part I. Overview of Spring Framework

The Spring Framework is a lightweight solution and a potential one-stop-shop for building your enterprise-ready applications. However, Spring is modular, allowing you to use only those parts that you need, without having to bring in the rest. You can use the IoC container, with any web framework on top, but you can also use only the Hibernate integration codeor the JDBC abstraction layer. The Spring Framework supports declarative transaction management, remote access to your logic through RMI or web services, and various options for persisting your data. It offers a full-featured MVC framework, and enables you to integrate AOPtransparently into your software.

Spring is designed to be non-intrusive, meaning that your domain logic code generally has no dependencies on the framework itself. In your integration layer (such as the data access layer), some dependencies on the data access technology and the Spring libraries will exist. However, it should be easy to isolate these dependencies from the rest of your code base.

This document is a reference guide to Spring Framework features. If you have any requests, comments, or questions on this document, please post them on the user mailing list. Questions on the Framework itself should be asked on StackOverflow (see https://spring.io/questions).

1. Getting Started with Spring

This reference guide provides detailed information about the Spring Framework. It provides comprehensive documentation for all features, as well as some background about the underlying concepts (such as "Dependency Injection") that Spring has embraced.

If you are just getting started with Spring, you may want to begin using the Spring Framework by creating a Spring Bootbased application. Spring Boot provides a quick (and opinionated) way to create a production-ready Spring based application. It is based on the Spring Framework, favors convention over configuration, and is designed to get you up and running as quickly as possible.

You can use start.spring.ioto generate a basic project or follow one of the "Getting Started" guideslike the Getting Started Building a RESTful Web Serviceone. As well as being easier to digest, these guides are very task focused, and most of them are based on Spring Boot. They also cover other projects from the Spring portfolio that you might want to consider when solving a particular problem.

2. Introduction to the Spring Framework

The Spring Framework is a Java platform that provides comprehensive infrastructure support for developing Java applications. Spring handles the infrastructure so you can focus on your application.

Spring enables you to build applications from "plain old Java objects" (POJOs) and to apply enterprise services non-invasively to POJOs. This capability applies to the Java SE programming model and to full and partial Java EE.

Examples of how you, as an application developer, can benefit from the Spring platform:

  • Make a Java method execute in a database transaction without having to deal with transaction APIs.
  • Make a local Java method a remote procedure without having to deal with remote APIs.
  • Make a local Java method a management operation without having to deal with JMX APIs.
  • Make a local Java method a message handler without having to deal with JMS APIs.

2.1 Dependency Injection and Inversion of Control

A Java application — a loose term that runs the gamut from constrained, embedded applications to n-tier, server-side enterprise applications — typically consists of objects that collaborate to form the application proper. Thus the objects in an application have dependencieson each other.

Although the Java platform provides a wealth of application development functionality, it lacks the means to organize the basic building blocks into a coherent whole, leaving that task to architects and developers. Although you can use design patterns such as Factory, Abstract Factory, Builder, Decorator, and Service Locatorto compose the various classes and object instances that make up an application, these patterns are simply that: best practices given a name, with a description of what the pattern does, where to apply it, the problems it addresses, and so forth. Patterns are formalized best practices that you must implement yourselfin your application.

The Spring Framework Inversion of Control(IoC) component addresses this concern by providing a formalized means of composing disparate components into a fully working application ready for use. The Spring Framework codifies formalized design patterns as first-class objects that you can integrate into your own application(s). Numerous organizations and institutions use the Spring Framework in this manner to engineer robust, maintainableapplications.

Background

" The question is, what aspect of control are [they] inverting?" Martin Fowler posed this question about Inversion of Control (IoC) on his sitein 2004. Fowler suggested renaming the principle to make it more self-explanatory and came up with Dependency Injection.

2.2 Modules

The Spring Framework consists of features organized into about 20 modules. These modules are grouped into Core Container, Data Access/Integration, Web, AOP (Aspect Oriented Programming), Instrumentation, Messaging, and Test, as shown in the following diagram.

Figure 2.1. Overview of the Spring Framework

spring overview

The following sections list the available modules for each feature along with their artifact names and the topics they cover. Artifact names correlate to artifact IDsused in Dependency Management tools.

2.2.1 Core Container

The Core Container consists of the spring-core, spring-beans, spring-context, spring-context-support, and spring-expression(Spring Expression Language) modules.

The spring-coreand spring-beansmodules provide the fundamental parts of the framework, including the IoC and Dependency Injection features. The BeanFactoryis a sophisticated implementation of the factory pattern. It removes the need for programmatic singletons and allows you to decouple the configuration and specification of dependencies from your actual program logic.

The Context ( spring-context) module builds on the solid base provided by the Core and Beans modules: it is a means to access objects in a framework-style manner that is similar to a JNDI registry. The Context module inherits its features from the Beans module and adds support for internationalization (using, for example, resource bundles), event propagation, resource loading, and the transparent creation of contexts by, for example, a Servlet container. The Context module also supports Java EE features such as EJB, JMX, and basic remoting. The ApplicationContextinterface is the focal point of the Context module. spring-context-supportprovides support for integrating common third-party libraries into a Spring application context for caching (EhCache, Guava, JCache), mailing (JavaMail), scheduling (CommonJ, Quartz) and template engines (FreeMarker, JasperReports, Velocity).

The spring-expressionmodule provides a powerful Expression Language for querying and manipulating an object graph at runtime. It is an extension of the unified expression language (unified EL) as specified in the JSP 2.1 specification. The language supports setting and getting property values, property assignment, method invocation, accessing the content of arrays, collections and indexers, logical and arithmetic operators, named variables, and retrieval of objects by name from Spring’s IoC container. It also supports list projection and selection as well as common list aggregations.

2.2.2 AOP and Instrumentation

The spring-aopmodule provides an AOP Alliance-compliant aspect-oriented programming implementation allowing you to define, for example, method interceptors and pointcuts to cleanly decouple code that implements functionality that should be separated. Using source-level metadata functionality, you can also incorporate behavioral information into your code, in a manner similar to that of .NET attributes.

The separate spring-aspectsmodule provides integration with AspectJ.

The spring-instrumentmodule provides class instrumentation support and classloader implementations to be used in certain application servers. The spring-instrument-tomcatmodule contains Spring’s instrumentation agent for Tomcat.

2.2.3 Messaging

Spring Framework 4 includes a spring-messagingmodule with key abstractions from the Spring Integrationproject such as Message, MessageChannel, MessageHandler, and others to serve as a foundation for messaging-based applications. The module also includes a set of annotations for mapping messages to methods, similar to the Spring MVC annotation based programming model.

2.2.4 Data Access/Integration

The Data Access/Integrationlayer consists of the JDBC, ORM, OXM, JMS, and Transaction modules.

The spring-jdbcmodule provides a JDBC-abstraction layer that removes the need to do tedious JDBC coding and parsing of database-vendor specific error codes.

The spring-txmodule supports programmatic and declarative transactionmanagement for classes that implement special interfaces and for all your POJOs (Plain Old Java Objects).

The spring-ormmodule provides integration layers for popular object-relational mappingAPIs, including JPA, JDO, and Hibernate. Using the spring-ormmodule you can use all of these O/R-mapping frameworks in combination with all of the other features Spring offers, such as the simple declarative transaction management feature mentioned previously.

The spring-oxmmodule provides an abstraction layer that supports Object/XML mappingimplementations such as JAXB, Castor, XMLBeans, JiBX and XStream.

The spring-jmsmodule ( Java Messaging Service) contains features for producing and consuming messages. Since Spring Framework 4.1, it provides integration with the spring-messagingmodule.

2.2.5 Web

The Weblayer consists of the spring-web, spring-webmvc, spring-websocket, and spring-webmvc-portletmodules.

The spring-webmodule provides basic web-oriented integration features such as multipart file upload functionality and the initialization of the IoC container using Servlet listeners and a web-oriented application context. It also contains an HTTP client and the web-related parts of Spring’s remoting support.

The spring-webmvcmodule (also known as the Web-Servletmodule) contains Spring’s model-view-controller ( MVC ) and REST Web Services implementation for web applications. Spring’s MVC framework provides a clean separation between domain model code and web forms and integrates with all of the other features of the Spring Framework.

The spring-webmvc-portletmodule (also known as the Web-Portletmodule) provides the MVC implementation to be used in a Portlet environment and mirrors the functionality of the spring-webmvcmodule.

2.2.6 Test

The spring-testmodule supports the unit testingand integration testingof Spring components with JUnit or TestNG. It provides consistent loadingof Spring ApplicationContexts and cachingof those contexts. It also provides mock objectsthat you can use to test your code in isolation.

2.3 Usage scenarios

The building blocks described previously make Spring a logical choice in many scenarios, from embedded applications that run on resource-constrained devices to full-fledged enterprise applications that use Spring’s transaction management functionality and web framework integration.

Figure 2.2. Typical full-fledged Spring web application

overview full

Spring’s declarative transaction management featuresmake the web application fully transactional, just as it would be if you used EJB container-managed transactions. All your custom business logic can be implemented with simple POJOs and managed by Spring’s IoC container. Additional services include support for sending email and validation that is independent of the web layer, which lets you choose where to execute validation rules. Spring’s ORM support is integrated with JPA, Hibernate and JDO; for example, when using Hibernate, you can continue to use your existing mapping files and standard Hibernate SessionFactoryconfiguration. Form controllers seamlessly integrate the web-layer with the domain model, removing the need for ActionFormsor other classes that transform HTTP parameters to values for your domain model.

Figure 2.3. Spring middle-tier using a third-party web framework

overview thirdparty web

Sometimes circumstances do not allow you to completely switch to a different framework. The Spring Framework does notforce you to use everything within it; it is not an all-or-nothingsolution. Existing front-ends built with Struts, Tapestry, JSF or other UI frameworks can be integrated with a Spring-based middle-tier, which allows you to use Spring transaction features. You simply need to wire up your business logic using an ApplicationContextand use a WebApplicationContextto integrate your web layer.

Figure 2.4. Remoting usage scenario

overview remoting

When you need to access existing code through web services, you can use Spring’s Hessian-, Burlap-, Rmi-or JaxRpcProxyFactoryclasses. Enabling remote access to existing applications is not difficult.

Figure 2.5. EJBs - Wrapping existing POJOs

overview ejb

The Spring Framework also provides an access and abstraction layerfor Enterprise JavaBeans, enabling you to reuse your existing POJOs and wrap them in stateless session beans for use in scalable, fail-safe web applications that might need declarative security.

2.3.1 Dependency Management and Naming Conventions

Dependency management and dependency injection are different things. To get those nice features of Spring into your application (like dependency injection) you need to assemble all the libraries needed (jar files) and get them onto your classpath at runtime, and possibly at compile time. These dependencies are not virtual components that are injected, but physical resources in a file system (typically). The process of dependency management involves locating those resources, storing them and adding them to classpaths. Dependencies can be direct (e.g. my application depends on Spring at runtime), or indirect (e.g. my application depends on commons-dbcpwhich depends on commons-pool). The indirect dependencies are also known as "transitive" and it is those dependencies that are hardest to identify and manage.

If you are going to use Spring you need to get a copy of the jar libraries that comprise the pieces of Spring that you need. To make this easier Spring is packaged as a set of modules that separate the dependencies as much as possible, so for example if you don’t want to write a web application you don’t need the spring-web modules. To refer to Spring library modules in this guide we use a shorthand naming convention spring-*or spring-*.jar,where *represents the short name for the module (e.g. spring-core, spring-webmvc, spring-jms, etc.). The actual jar file name that you use is normally the module name concatenated with the version number (e.g. spring-core-4.3.4.RELEASE.jar).

Each release of the Spring Framework will publish artifacts to the following places:

  • Maven Central, which is the default repository that Maven queries, and does not require any special configuration to use. Many of the common libraries that Spring depends on also are available from Maven Central and a large section of the Spring community uses Maven for dependency management, so this is convenient for them. The names of the jars here are in the form spring-*-<version>.jarand the Maven groupId is org.springframework.
  • In a public Maven repository hosted specifically for Spring. In addition to the final GA releases, this repository also hosts development snapshots and milestones. The jar file names are in the same form as Maven Central, so this is a useful place to get development versions of Spring to use with other libraries deployed in Maven Central. This repository also contains a bundle distribution zip file that contains all Spring jars bundled together for easy download.

So the first thing you need to decide is how to manage your dependencies: we generally recommend the use of an automated system like Maven, Gradle or Ivy, but you can also do it manually by downloading all the jars yourself.

You will find bellow the list of Spring artifacts. For a more complete description of each modules, see Section 2.2, “Modules”.

Table 2.1. Spring Framework Artifacts

GroupId ArtifactId Description

org.springframework

spring-aop

Proxy-based AOP support

org.springframework

spring-aspects

AspectJ based aspects

org.springframework

spring-beans

Beans support, including Groovy

org.springframework

spring-context

Application context runtime, including scheduling and remoting abstractions

org.springframework

spring-context-support

Support classes for integrating common third-party libraries into a Spring application context

org.springframework

spring-core

Core utilities, used by many other Spring modules

org.springframework

spring-expression

Spring Expression Language (SpEL)

org.springframework

spring-instrument

Instrumentation agent for JVM bootstrapping

org.springframework

spring-instrument-tomcat

Instrumentation agent for Tomcat

org.springframework

spring-jdbc

JDBC support package, including DataSource setup and JDBC access support

org.springframework

spring-jms

JMS support package, including helper classes to send and receive JMS messages

org.springframework

spring-messaging

Support for messaging architectures and protocols

org.springframework

spring-orm

Object/Relational Mapping, including JPA and Hibernate support

org.springframework

spring-oxm

Object/XML Mapping

org.springframework

spring-test

Support for unit testing and integration testing Spring components

org.springframework

spring-tx

Transaction infrastructure, including DAO support and JCA integration

org.springframework

spring-web

Web support packages, including client and web remoting

org.springframework

spring-webmvc

REST Web Services and model-view-controller implementation for web applications

org.springframework

spring-webmvc-portlet

MVC implementation to be used in a Portlet environment

org.springframework

spring-websocket

WebSocket and SockJS implementations, including STOMP support

Spring Dependencies and Depending on Spring

Although Spring provides integration and support for a huge range of enterprise and other external tools, it intentionally keeps its mandatory dependencies to an absolute minimum: you shouldn’t have to locate and download (even automatically) a large number of jar libraries in order to use Spring for simple use cases. For basic dependency injection there is only one mandatory external dependency, and that is for logging (see below for a more detailed description of logging options).

Next we outline the basic steps needed to configure an application that depends on Spring, first with Maven and then with Gradle and finally using Ivy. In all cases, if anything is unclear, refer to the documentation of your dependency management system, or look at some sample code - Spring itself uses Gradle to manage dependencies when it is building, and our samples mostly use Gradle or Maven.

Maven Dependency Management

If you are using Mavenfor dependency management you don’t even need to supply the logging dependency explicitly. For example, to create an application context and use dependency injection to configure an application, your Maven dependencies will look like this:

									<dependencies>
									<dependency>
									<groupId>org.springframework
									</groupId>
									<artifactId>spring-context
									</artifactId>
									<version>4.3.4.RELEASE
									</version>
									<scope>runtime
									</scope>
									</dependency>
									</dependencies>

That’s it. Note the scope can be declared as runtime if you don’t need to compile against Spring APIs, which is typically the case for basic dependency injection use cases.

The example above works with the Maven Central repository. To use the Spring Maven repository (e.g. for milestones or developer snapshots), you need to specify the repository location in your Maven configuration. For full releases:

									<repositories>
									<repository>
									<id>io.spring.repo.maven.release
									</id>
									<url>http://repo.spring.io/release/
									</url>
									<snapshots>
									<enabled>false
									</enabled>
									</snapshots>
									</repository>
									</repositories>

For milestones:

									<repositories>
									<repository>
									<id>io.spring.repo.maven.milestone
									</id>
									<url>http://repo.spring.io/milestone/
									</url>
									<snapshots>
									<enabled>false
									</enabled>
									</snapshots>
									</repository>
									</repositories>

And for snapshots:

									<repositories>
									<repository>
									<id>io.spring.repo.maven.snapshot
									</id>
									<url>http://repo.spring.io/snapshot/
									</url>
									<snapshots>
									<enabled>true
									</enabled>
									</snapshots>
									</repository>
									</repositories>

Maven "Bill Of Materials" Dependency

It is possible to accidentally mix different versions of Spring JARs when using Maven. For example, you may find that a third-party library, or another Spring project, pulls in a transitive dependency to an older release. If you forget to explicitly declare a direct dependency yourself, all sorts of unexpected issues can arise.

To overcome such problems Maven supports the concept of a "bill of materials" (BOM) dependency. You can import the spring-framework-bomin your dependencyManagementsection to ensure that all spring dependencies (both direct and transitive) are at the same version.

									<dependencyManagement>
									<dependencies>
									<dependency>
									<groupId>org.springframework
									</groupId>
									<artifactId>spring-framework-bom
									</artifactId>
									<version>4.3.4.RELEASE
									</version>
									<type>pom
									</type>
									<scope>import
									</scope>
									</dependency>
									</dependencies>
									</dependencyManagement>

An added benefit of using the BOM is that you no longer need to specify the <version>attribute when depending on Spring Framework artifacts:

									<dependencies>
									<dependency>
									<groupId>org.springframework
									</groupId>
									<artifactId>spring-context
									</artifactId>
									</dependency>
									<dependency>
									<groupId>org.springframework
									</groupId>
									<artifactId>spring-web
									</artifactId>
									</dependency>
									<dependencies>

Gradle Dependency Management

To use the Spring repository with the Gradlebuild system, include the appropriate URL in the repositoriessection:

repositories { mavenCentral()
									// and optionally...maven { url
									"http://repo.spring.io/release"} }

You can change the repositoriesURL from /releaseto /milestoneor /snapshotas appropriate. Once a repository has been configured, you can declare dependencies in the usual Gradle way:

dependencies { compile(
									"org.springframework:spring-context:4.3.4.RELEASE") testCompile(
									"org.springframework:spring-test:4.3.4.RELEASE") }

Ivy Dependency Management

If you prefer to use Ivyto manage dependencies then there are similar configuration options.

To configure Ivy to point to the Spring repository add the following resolver to your ivysettings.xml:

									<resolvers>
									<ibiblio
									name=
									"io.spring.repo.maven.release"
									m2compatible=
									"true"
									root=
									"http://repo.spring.io/release/"
									/>
									</resolvers>

You can change the rootURL from /release/to /milestone/or /snapshot/as appropriate.

Once configured, you can add dependencies in the usual way. For example (in ivy.xml):

									<dependency
									org=
									"org.springframework"
									name=
									"spring-core"
									rev=
									"4.3.4.RELEASE"
									conf=
									"compile->runtime"
									/>

Distribution Zip Files

Although using a build system that supports dependency management is the recommended way to obtain the Spring Framework, it is still possible to download a distribution zip file.

Distribution zips are published to the Spring Maven Repository (this is just for our convenience, you don’t need Maven or any other build system in order to download them).

To download a distribution zip open a web browser to http://repo.spring.io/release/org/springframework/springand select the appropriate subfolder for the version that you want. Distribution files end -dist.zip, for example spring-framework-{spring-version}-RELEASE-dist.zip. Distributions are also published for milestonesand snapshots.

2.3.2 Logging

Logging is a very important dependency for Spring because a)it is the only mandatory external dependency, b)everyone likes to see some output from the tools they are using, and c)Spring integrates with lots of other tools all of which have also made a choice of logging dependency. One of the goals of an application developer is often to have unified logging configured in a central place for the whole application, including all external components. This is more difficult than it might have been since there are so many choices of logging framework.

The mandatory logging dependency in Spring is the Jakarta Commons Logging API (JCL). We compile against JCL and we also make JCL Logobjects visible for classes that extend the Spring Framework. It’s important to users that all versions of Spring use the same logging library: migration is easy because backwards compatibility is preserved even with applications that extend Spring. The way we do this is to make one of the modules in Spring depend explicitly on commons-logging(the canonical implementation of JCL), and then make all the other modules depend on that at compile time. If you are using Maven for example, and wondering where you picked up the dependency on commons-logging, then it is from Spring and specifically from the central module called spring-core.

The nice thing about commons-loggingis that you don’t need anything else to make your application work. It has a runtime discovery algorithm that looks for other logging frameworks in well known places on the classpath and uses one that it thinks is appropriate (or you can tell it which one if you need to). If nothing else is available you get pretty nice looking logs just from the JDK (java.util.logging or JUL for short). You should find that your Spring application works and logs happily to the console out of the box in most situations, and that’s important.

Not Using Commons Logging

Unfortunately, the runtime discovery algorithm in commons-logging, while convenient for the end-user, is problematic. If we could turn back the clock and start Spring now as a new project it would use a different logging dependency. The first choice would probably be the Simple Logging Facade for Java ( SLF4J), which is also used by a lot of other tools that people use with Spring inside their applications.

There are basically two ways to switch off commons-logging:

  1. Exclude the dependency from the spring-coremodule (as it is the only module that explicitly depends on commons-logging)
  2. Depend on a special commons-loggingdependency that replaces the library with an empty jar (more details can be found in the SLF4J FAQ)

To exclude commons-logging, add the following to your dependencyManagementsection:

									<dependencies>
									<dependency>
									<groupId>org.springframework
									</groupId>
									<artifactId>spring-core
									</artifactId>
									<version>4.3.4.RELEASE
									</version>
									<exclusions>
									<exclusion>
									<groupId>commons-logging
									</groupId>
									<artifactId>commons-logging
									</artifactId>
									</exclusion>
									</exclusions>
									</dependency>
									</dependencies>

Now this application is probably broken because there is no implementation of the JCL API on the classpath, so to fix it a new one has to be provided. In the next section we show you how to provide an alternative implementation of JCL using SLF4J as an example.

Using SLF4J

SLF4J is a cleaner dependency and more efficient at runtime than commons-loggingbecause it uses compile-time bindings instead of runtime discovery of the other logging frameworks it integrates. This also means that you have to be more explicit about what you want to happen at runtime, and declare it or configure it accordingly. SLF4J provides bindings to many common logging frameworks, so you can usually choose one that you already use, and bind to that for configuration and management.

SLF4J provides bindings to many common logging frameworks, including JCL, and it also does the reverse: bridges between other logging frameworks and itself. So to use SLF4J with Spring you need to replace the commons-loggingdependency with the SLF4J-JCL bridge. Once you have done that then logging calls from within Spring will be translated into logging calls to the SLF4J API, so if other libraries in your application use that API, then you have a single place to configure and manage logging.

A common choice might be to bridge Spring to SLF4J, and then provide explicit binding from SLF4J to Log4J. You need to supply 4 dependencies (and exclude the existing commons-logging): the bridge, the SLF4J API, the binding to Log4J, and the Log4J implementation itself. In Maven you would do that like this

									<dependencies>
									<dependency>
									<groupId>org.springframework
									</groupId>
									<artifactId>spring-core
									</artifactId>
									<version>4.3.4.RELEASE
									</version>
									<exclusions>
									<exclusion>
									<groupId>commons-logging
									</groupId>
									<artifactId>commons-logging
									</artifactId>
									</exclusion>
									</exclusions>
									</dependency>
									<dependency>
									<groupId>org.slf4j
									</groupId>
									<artifactId>jcl-over-slf4j
									</artifactId>
									<version>1.5.8
									</version>
									</dependency>
									<dependency>
									<groupId>org.slf4j
									</groupId>
									<artifactId>slf4j-api
									</artifactId>
									<version>1.5.8
									</version>
									</dependency>
									<dependency>
									<groupId>org.slf4j
									</groupId>
									<artifactId>slf4j-log4j12
									</artifactId>
									<version>1.5.8
									</version>
									</dependency>
									<dependency>
									<groupId>log4j
									</groupId>
									<artifactId>log4j
									</artifactId>
									<version>1.2.14
									</version>
									</dependency>
									</dependencies>

That might seem like a lot of dependencies just to get some logging. Well it is, but it isoptional, and it should behave better than the vanilla commons-loggingwith respect to classloader issues, notably if you are in a strict container like an OSGi platform. Allegedly there is also a performance benefit because the bindings are at compile-time not runtime.

A more common choice amongst SLF4J users, which uses fewer steps and generates fewer dependencies, is to bind directly to Logback. This removes the extra binding step because Logback implements SLF4J directly, so you only need to depend on two libraries not four ( jcl-over-slf4jand logback). If you do that you might also need to exclude the slf4j-api dependency from other external dependencies (not Spring), because you only want one version of that API on the classpath.

Using Log4J

Many people use Log4jas a logging framework for configuration and management purposes. It’s efficient and well-established, and in fact it’s what we use at runtime when we build and test Spring. Spring also provides some utilities for configuring and initializing Log4j, so it has an optional compile-time dependency on Log4j in some modules.

To make Log4j work with the default JCL dependency ( commons-logging) all you need to do is put Log4j on the classpath, and provide it with a configuration file ( log4j.propertiesor log4j.xmlin the root of the classpath). So for Maven users this is your dependency declaration:

									<dependencies>
									<dependency>
									<groupId>org.springframework
									</groupId>
									<artifactId>spring-core
									</artifactId>
									<version>4.3.4.RELEASE
									</version>
									</dependency>
									<dependency>
									<groupId>log4j
									</groupId>
									<artifactId>log4j
									</artifactId>
									<version>1.2.14
									</version>
									</dependency>
									</dependencies>

And here’s a sample log4j.properties for logging to the console:

log4j.rootCategory=INFO, stdout log4j.appender.stdout=org.apache.log4j.ConsoleAppender log4j.appender.stdout.layout=org.apache.log4j.PatternLayout log4j.appender.stdout.layout.ConversionPattern=%d{ABSOLUTE} %5p %t %c{2}:%L - %m%n log4j.category.org.springframework.beans.factory=DEBUG
Runtime Containers with Native JCL

Many people run their Spring applications in a container that itself provides an implementation of JCL. IBM Websphere Application Server (WAS) is the archetype. This often causes problems, and unfortunately there is no silver bullet solution; simply excluding commons-loggingfrom your application is not enough in most situations.

To be clear about this: the problems reported are usually not with JCL per se, or even with commons-logging: rather they are to do with binding commons-loggingto another framework (often Log4J). This can fail because commons-loggingchanged the way they do the runtime discovery in between the older versions (1.0) found in some containers and the modern versions that most people use now (1.1). Spring does not use any unusual parts of the JCL API, so nothing breaks there, but as soon as Spring or your application tries to do any logging you can find that the bindings to Log4J are not working.

In such cases with WAS the easiest thing to do is to invert the class loader hierarchy (IBM calls it "parent last") so that the application controls the JCL dependency, not the container. That option isn’t always open, but there are plenty of other suggestions in the public domain for alternative approaches, and your mileage may vary depending on the exact version and feature set of the container.

Part II. What’s New in Spring Framework 4.x

3. New Features and Enhancements in Spring Framework 4.0

The Spring Framework was first released in 2004; since then there have been significant major revisions: Spring 2.0 provided XML namespaces and AspectJ support; Spring 2.5 embraced annotation-driven configuration; Spring 3.0 introduced a strong Java 5+ foundation across the framework codebase, and features such as the Java-based @Configurationmodel.

Version 4.0 is the latest major release of the Spring Framework and the first to fully support Java 8 features. You can still use Spring with older versions of Java, however, the minimum requirement has now been raised to Java SE 6. We have also taken the opportunity of a major release to remove many deprecated classes and methods.

A migration guide for upgrading to Spring 4.0is available on the Spring Framework GitHub Wiki.

3.1 Improved Getting Started Experience

The new spring.iowebsite provides a whole series of "Getting Started"guides to help you learn Spring. You can read more about the guides in the Chapter 1, Getting Started with Spring section in this document. The new website also provides a comprehensive overview of the many additional projects that are released under the Spring umbrella.

If you are a Maven user you may also be interested in the helpful bill of materialsPOM file that is now published with each Spring Framework release.

3.2 Removed Deprecated Packages and Methods

All deprecated packages, and many deprecated classes and methods have been removed with version 4.0. If you are upgrading from a previous release of Spring, you should ensure that you have fixed any deprecated calls that you were making to outdated APIs.

For a complete set of changes, check out the API Differences Report.

Note that optional third-party dependencies have been raised to a 2010/2011 minimum (i.e. Spring 4 generally only supports versions released in late 2010 or later now): notably, Hibernate 3.6+, EhCache 2.1+, Quartz 1.8+, Groovy 1.8+, and Joda-Time 2.0+. As an exception to the rule, Spring 4 requires the recent Hibernate Validator 4.3+, and support for Jackson has been focused on 2.0+ now (with Jackson 1.8/1.9 support retained for the time being where Spring 3.2 had it; now just in deprecated form).

3.3 Java 8 (as well as 6 and 7)

Spring Framework 4.0 provides support for several Java 8 features. You can make use of lambda expressionsand method referenceswith Spring’s callback interfaces. There is first-class support for java.time( JSR-310), and several existing annotations have been retrofitted as @Repeatable. You can also use Java 8’s parameter name discovery (based on the -parameterscompiler flag) as an alternative to compiling your code with debug information enabled.

Spring remains compatible with older versions of Java and the JDK: concretely, Java SE 6 (specifically, a minimum level equivalent to JDK 6 update 18, as released in January 2010) and above are still fully supported. However, for newly started development projects based on Spring 4, we recommend the use of Java 7 or 8.

3.4 Java EE 6 and 7

Java EE version 6 or above is now considered the baseline for Spring Framework 4, with the JPA 2.0 and Servlet 3.0 specifications being of particular relevance. In order to remain compatible with Google App Engine and older application servers, it is possible to deploy a Spring 4 application into a Servlet 2.5 environment. However, Servlet 3.0+ is strongly recommended and a prerequisite in Spring’s test and mock packages for test setups in development environments.

[Note] Note

If you are a WebSphere 7 user, be sure to install the JPA 2.0 feature pack. On WebLogic 10.3.4 or higher, install the JPA 2.0 patch that comes with it. This turns both of those server generations into Spring 4 compatible deployment environments.

On a more forward-looking note, Spring Framework 4.0 supports the Java EE 7 level of applicable specifications now: in particular, JMS 2.0, JTA 1.2, JPA 2.1, Bean Validation 1.1, and JSR-236 Concurrency Utilities. As usual, this support focuses on individual use of those specifications, e.g. on Tomcat or in standalone environments. However, it works equally well when a Spring application is deployed to a Java EE 7 server.

Note that Hibernate 4.3 is a JPA 2.1 provider and therefore only supported as of Spring Framework 4.0. The same applies to Hibernate Validator 5.0 as a Bean Validation 1.1 provider. Neither of the two are officially supported with Spring Framework 3.2.

3.5 Groovy Bean Definition DSL

Beginning with Spring Framework 4.0, it is possible to define external bean configuration using a Groovy DSL. This is similar in concept to using XML bean definitions but allows for a more concise syntax. Using Groovy also allows you to easily embed bean definitions directly in your bootstrap code. For example:

def reader =
							newGroovyBeanDefinitionReader(myApplicationContext) reader.beans { dataSource(BasicDataSource) { driverClassName =
							"org.hsqldb.jdbcDriver"url =
							"jdbc:hsqldb:mem:grailsDB"username =
							"sa"password =
							""settings = [mynew:
							"setting"] } sessionFactory(SessionFactory) { dataSource = dataSource } myService(MyService) { nestedBean = { AnotherBean bean -> dataSource = dataSource } } }

For more information consult the GroovyBeanDefinitionReader javadocs.

3.6 Core Container Improvements

There have been several general improvements to the core container:

  • Spring now treats generic typesas a form of qualifier when injecting Beans. For example, if you are using a Spring Data Repositoryyou can now easily inject a specific implementation: @Autowired Repository<Customer> customerRepository.
  • If you use Spring’s meta-annotation support, you can now develop custom annotations that expose specific attributes from the source annotation.
  • Beans can now be orderedwhen they are autowired into lists and arrays. Both the @Orderannotation and Orderedinterface are supported.
  • The @Lazyannotation can now be used on injection points, as well as on @Beandefinitions.
  • The @Descriptionannotation has been introducedfor developers using Java-based configuration.
  • A generalized model for conditionally filtering beanshas been added via the @Conditionalannotation. This is similar to @Profilesupport but allows for user-defined strategies to be developed programmatically.
  • CGLIB-based proxy classesno longer require a default constructor. Support is provided via the objenesislibrary which is repackaged inlineand distributed as part of the Spring Framework. With this strategy, no constructor at all is being invoked for proxy instances anymore.
  • There is managed time zone support across the framework now, e.g. on LocaleContext.

3.7 General Web Improvements

Deployment to Servlet 2.5 servers remains an option, but Spring Framework 4.0 is now focused primarily on Servlet 3.0+ environments. If you are using the Spring MVC Test Frameworkyou will need to ensure that a Servlet 3.0 compatible JAR is in your test classpath.

In addition to the WebSocket support mentioned later, the following general improvements have been made to Spring’s Web modules:

3.8 WebSocket, SockJS, and STOMP Messaging

A new spring-websocketmodule provides comprehensive support for WebSocket-based, two-way communication between client and server in web applications. It is compatible with JSR-356, the Java WebSocket API, and in addition provides SockJS-based fallback options (i.e. WebSocket emulation) for use in browsers that don’t yet support the WebSocket protocol (e.g. Internet Explorer < 10).

A new spring-messagingmodule adds support for STOMP as the WebSocket sub-protocol to use in applications along with an annotation programming model for routing and processing STOMP messages from WebSocket clients. As a result an @Controllercan now contain both @RequestMappingand @MessageMappingmethods for handling HTTP requests and messages from WebSocket-connected clients. The new spring-messagingmodule also contains key abstractions formerly from the Spring Integrationproject such as Message, MessageChannel, MessageHandler, and others to serve as a foundation for messaging-based applications.

For further details, including a more thorough introduction, see the Chapter 26, WebSocket Support section.

3.9 Testing Improvements

In addition to pruning of deprecated code within the spring-testmodule, Spring Framework 4.0 introduces several new features for use in unit and integration testing.

  • Almost all annotations in the spring-testmodule (e.g., @ContextConfiguration, @WebAppConfiguration, @ContextHierarchy, @ActiveProfiles, etc.) can now be used as meta-annotationsto create custom composed annotationsand reduce configuration duplication across a test suite.
  • Active bean definition profiles can now be resolved programmatically, simply by implementing a custom ActiveProfilesResolverand registering it via the resolverattribute of @ActiveProfiles.
  • A new SocketUtilsclass has been introduced in the spring-coremodule which enables you to scan for free TCP and UDP server ports on localhost. This functionality is not specific to testing but can prove very useful when writing integration tests that require the use of sockets, for example tests that start an in-memory SMTP server, FTP server, Servlet container, etc.
  • As of Spring 4.0, the set of mocks in the org.springframework.mock.webpackage is now based on the Servlet 3.0 API. Furthermore, several of the Servlet API mocks (e.g., MockHttpServletRequest, MockServletContext, etc.) have been updated with minor enhancements and improved configurability.

4. New Features and Enhancements in Spring Framework 4.1

4.1 JMS Improvements

Spring 4.1 introduces a much simpler infrastructure to register JMS listener endpointsby annotating bean methods with @JmsListener. The XML namespace has been enhanced to support this new style ( jms:annotation-driven), and it is also possible to fully configure the infrastructure using Java config ( @EnableJms, JmsListenerContainerFactory). It is also possible to register listener endpoints programmatically using JmsListenerConfigurer.

Spring 4.1 also aligns its JMS support to allow you to benefit from the spring-messagingabstraction introduced in 4.0, that is:

  • Message listener endpoints can have a more flexible signature and benefit from standard messaging annotations such as @Payload, @Header, @Headers, and @SendTo. It is also possible to use a standard Messagein lieu of javax.jms.Messageas method argument.
  • A new JmsMessageOperationsinterface is available and permits JmsTemplatelike operations using the Messageabstraction.

Finally, Spring 4.1 provides additional miscellaneous improvements:

  • Synchronous request-reply operations support in JmsTemplate
  • Listener priority can be specified per <jms:listener/>element
  • Recovery options for the message listener container are configurable using a BackOffimplementation
  • JMS 2.0 shared consumers are supported

4.2 Caching Improvements

Spring 4.1 supports JCache (JSR-107) annotationsusing Spring’s existing cache configuration and infrastructure abstraction; no changes are required to use the standard annotations.

Spring 4.1 also improves its own caching abstraction significantly:

  • Caches can be resolved at runtime using a CacheResolver. As a result the valueargument defining the cache name(s) to use is no longer mandatory.
  • More operation-level customizations: cache resolver, cache manager, key generator
  • A new @CacheConfigclass-level annotationallows common settings to be shared at the class level withoutenabling any cache operation.
  • Better exception handling of cached methods using CacheErrorHandler

Spring 4.1 also has a breaking change in the Cacheinterface as a new putIfAbsentmethod has been added.

4.3 Web Improvements

  • The existing support for resource handling based on the ResourceHttpRequestHandlerhas been expanded with new abstractions ResourceResolver, ResourceTransformer, and ResourceUrlProvider. A number of built-in implementations provide support for versioned resource URLs (for effective HTTP caching), locating gzipped resources, generating an HTML 5 AppCache manifests, and more. See Section 22.16.9, “Serving of Resources”.
  • JDK 1.8’s java.util.Optionalis now supported for @RequestParam, @RequestHeader, and @MatrixVariablecontroller method arguments.
  • ListenableFutureis supported as a return value alternative to DeferredResultwhere an underlying service (or perhaps a call to AsyncRestTemplate) already returns ListenableFuture.
  • @ModelAttributemethods are now invoked in an order that respects inter-dependencies. See SPR-6299.
  • Jackson’s @JsonViewis supported directly on @ResponseBodyand ResponseEntitycontroller methods for serializing different amounts of detail for the same POJO (e.g. summary vs. detail page). This is also supported with View-based rendering by adding the serialization view type as a model attribute under a special key. See the section called “Jackson Serialization View Support”for details.
  • JSONP is now supported with Jackson. See the section called “Jackson JSONP Support”.
  • A new lifecycle option is available for intercepting @ResponseBodyand ResponseEntitymethods just after the controller method returns and before the response is written. To take advantage declare an @ControllerAdvicebean that implements ResponseBodyAdvice. The built-in support for @JsonViewand JSONP take advantage of this. See Section 22.4.1, “Intercepting requests with a HandlerInterceptor”.

  • There are three new HttpMessageConverteroptions:

    • Gson — lighter footprint than Jackson; has already been in use in Spring Android.
    • Google Protocol Buffers — efficient and effective as an inter-service communication data protocol within an enterprise but can also be exposed as JSON and XML for browsers.
    • Jackson based XML serialization is now supported through the jackson-dataformat-xmlextension. When using @EnableWebMvcor <mvc:annotation-driven/>, this is used by default instead of JAXB2 if jackson-dataformat-xmlis in the classpath.
  • Views such as JSPs can now build links to controllers by referring to controller mappings by name. A default name is assigned to every @RequestMapping. For example FooControllerwith method handleFoois named "FC#handleFoo". The naming strategy is pluggable. It is also possible to name an @RequestMappingexplicitly through its name attribute. A new mvcUrlfunction in the Spring JSP tag library makes this easy to use in JSP pages. See Section 22.7.2, “Building URIs to Controllers and methods from views”.
  • ResponseEntityprovides a builder-style API to guide controller methods towards the preparation of server-side responses, e.g. ResponseEntity.ok().
  • RequestEntityis a new type that provides a builder-style API to guide client-side REST code towards the preparation of HTTP requests.

  • MVC Java config and XML namespace:

    • View resolvers can now be configured including support for content negotiation, see Section 22.16.8, “View Resolvers”.
    • View controllers now have built-in support for redirects and for setting the response status. An application can use this to configure redirect URLs, render 404 responses with a view, send "no content" responses, etc. Some use cases are listed here.
    • Path matching customizations are frequently used and now built-in. See Section 22.16.11, “Path Matching”.
  • Groovy markup templatesupport (based on Groovy 2.3). See the GroovyMarkupConfigurerand respecitve ViewResolverand `View' implementations.

4.4 WebSocket Messaging Improvements

  • SockJS (Java) client-side support. See SockJsClientand classes in same package.
  • New application context events SessionSubscribeEventand SessionUnsubscribeEventpublished when STOMP clients subscribe and unsubscribe.
  • New "websocket" scope. See Section 26.4.14, “WebSocket Scope”.
  • @SendToUsercan target only a single session and does not require an authenticated user.
  • @MessageMappingmethods can use dot "." instead of slash "/" as path separator. See SPR-11660.
  • STOMP/WebSocket monitoring info collected and logged. See Section 26.4.16, “Runtime Monitoring”.
  • Significantly optimized and improved logging that should remain very readable and compact even at DEBUG level.
  • Optimized message creation including support for temporary message mutability and avoiding automatic message id and timestamp creation. See Javadoc of MessageHeaderAccessor.
  • Close STOMP/WebSocket connections that have no activity within 60 seconds after the WebSocket session is established. See SPR-11884.

4.5 Testing Improvements

5. New Features and Enhancements in Spring Framework 4.2

5.1 Core Container Improvements

  • Annotations such as @Beanget detected and processed on Java 8 default methods as well, allowing for composing a configuration class from interfaces with default @Beanmethods.
  • Configuration classes may declare @Importwith regular component classes now, allowing for a mix of imported configuration classes and component classes.
  • Configuration classes may declare an @Ordervalue, getting processed in a corresponding order (e.g. for overriding beans by name) even when detected through classpath scanning.
  • @Resourceinjection points support an @Lazydeclaration, analogous to @Autowired, receiving a lazy-initializing proxy for the requested target bean.

  • The application event infrastructure now offers an annotation-based modelas well as the ability to publish any arbitrary event.

    • Any public method in a managed bean can be annotated with @EventListenerto consume events.
    • @TransactionalEventListenerprovides transaction-bound event support.

  • Spring Framework 4.2 introduces first-class support for declaring and looking up aliases for annotation attributes. The new @AliasForannotation can be used to declare a pair of aliased attributes within a single annotation or to declare an alias from one attribute in a custom composed annotation to an attribute in a meta-annotation.

    • The following annotations have been retrofitted with @AliasForsupport in order to provide meaningful aliases for their valueattributes: @Cacheable, @CacheEvict, @CachePut, @ComponentScan, @ComponentScan.Filter, @ImportResource, @Scope, @ManagedResource, @Header, @Payload, @SendToUser, @ActiveProfiles, @ContextConfiguration, @Sql, @TestExecutionListeners, @TestPropertySource, @Transactional, @ControllerAdvice, @CookieValue, @CrossOrigin, @MatrixVariable, @RequestHeader, @RequestMapping, @RequestParam, @RequestPart, @ResponseStatus, @SessionAttributes, @ActionMapping, @RenderMapping, @EventListener, @TransactionalEventListener.

    • For example, @ContextConfigurationfrom the spring-testmodule is now declared as follows:

      													public
													
														@interfaceContextConfiguration {
													
														@AliasFor("locations")String[] value()
													default{};
													
														@AliasFor("value")String[] locations()
													default{};
													// ...}
    • Similarly, composed annotationsthat override attributes from meta-annotations can now use @AliasForfor fine-grained control over exactly which attributes are overridden within an annotation hierarchy. In fact, it is now possible to declare an alias for the valueattribute of a meta-annotation.

    • For example, one can now develop a composed annotation with a custom attribute override as follows.

      													
														@ContextConfiguration
													public
													
														@interfaceMyTestConfig {
													
														@AliasFor(annotation = ContextConfiguration.class, attribute = "value")String[] xmlFiles();
													// ...}
    • See Spring Annotation Programming Model.
  • Numerous improvements to Spring’s search algorithms used for finding meta-annotations. For example, locally declared composed annotationsare now favored over inherited annotations.
  • Composed annotationsthat override attributes from meta-annotations can now be discovered on interfaces and on abstract, bridge, & interface methods as well as on classes, standard methods, constructors, and fields.
  • Maps representing annotation attributes (and AnnotationAttributesinstances) can be synthesized(i.e., converted) into an annotation.
  • The features of field-based data binding ( DirectFieldAccessor) have been aligned with the current property-based data binding ( BeanWrapper). In particular, field-based binding now supports navigation for Collections, Arrays, and Maps.
  • DefaultConversionServicenow provides out-of-the-box converters for Stream, Charset, Currency, and TimeZone. Such converters can be added individually to any arbitrary ConversionServiceas well.
  • DefaultFormattingConversionServicecomes with out-of-the-box support for the value types in JSR-354 Money & Currency (if the 'javax.money' API is present on the classpath): namely, MonetaryAmountand CurrencyUnit. This includes support for applying @NumberFormat.
  • @NumberFormatcan now be used as a meta-annotation.
  • JavaMailSenderImplhas a new testConnection()method for checking connectivity to the server.
  • ScheduledTaskRegistrarexposes scheduled tasks.
  • Apache commons-pool2is now supported for a pooling AOP CommonsPool2TargetSource.
  • Introduced StandardScriptFactoryas a JSR-223 based mechanism for scripted beans, exposed through the lang:stdelement in XML. Supports e.g. JavaScript and JRuby. (Note: JRubyScriptFactory and lang:jrubyare deprecated now, in favor of using JSR-223.)

5.2 Data Access Improvements

  • javax.transaction.Transactionalis now supported via AspectJ.
  • SimpleJdbcCallOperationsnow supports named binding.
  • Full support for Hibernate ORM 5.0: as a JPA provider (automatically adapted) as well as through its native API (covered by the new org.springframework.orm.hibernate5package).
  • Embedded databases can now be automatically assigned unique names, and <jdbc:embedded-database>supports a new database-nameattribute. See "Testing Improvements" below for further details.

5.3 JMS Improvements

  • The autoStartupattribute can be controlled via JmsListenerContainerFactory.
  • The type of the reply Destinationcan now be configured per listener container.
  • The value of the @SendToannotation can now use a SpEL expression.
  • The response destination can be computed at runtime using JmsResponse
  • @JmsListeneris now a repeatable annotation to declare several JMS containers on the same method (use the newly introduced @JmsListenersif you’re not using Java8 yet).

5.4 Web Improvements

  • HTTP Streaming and Server-Sent Events support, see the section called “HTTP Streaming”.
  • Built-in support for CORS including global (MVC Java config and XML namespace) and local (e.g. @CrossOrigin) configuration. See Chapter 27, CORS Support for details.

  • HTTP caching updates:

    • new CacheControlbuilder; plugged into ResponseEntity, WebContentGenerator, ResourceHttpRequestHandler.
    • improved ETag/Last-Modified support in WebRequest.
  • Custom mapping annotations, using @RequestMappingas a meta-annotation.
  • Public methods in AbstractHandlerMethodMappingto register and unregister request mappings at runtime.
  • Protected createDispatcherServletmethod in AbstractDispatcherServletInitializerto further customize the DispatcherServletinstance to use.
  • HandlerMethodas a method argument on @ExceptionHandlermethods, especially handy in @ControllerAdvicecomponents.
  • java.util.concurrent.CompletableFutureas an @Controllermethod return value type.
  • Byte-range request support in HttpHeadersand for serving static resources.
  • @ResponseStatusdetected on nested exceptions.

  • UriTemplateHandlerextension point in the RestTemplate.

    • DefaultUriTemplateHandlerexposes baseUrlproperty and path segment encoding options.
    • the extension point can also be used to plug in any URI template library.
  • OkHTTPintegration with the RestTemplate.
  • Custom baseUrlalternative for methods in MvcUriComponentsBuilder.
  • Serialization/deserialization exception messages are now logged at WARN level.
  • Default JSON prefix has been changed from "{} && " to the safer ")]}', " one.
  • New RequestBodyAdviceextension point and built-in implementation to support Jackson’s @JsonViewon @RequestBodymethod arguments.
  • When using GSON or Jackson 2.6+, the handler method return type is used to improve serialization of parameterized types like List<Foo>.
  • Introduced ScriptTemplateViewas a JSR-223 based mechanism for scripted web views, with a focus on JavaScript view templating on Nashorn (JDK 8).

5.5 WebSocket Messaging Improvements

  • Expose presence information about connected users and subscriptions:

    • new SimpUserRegistryexposed as a bean named "userRegistry".
    • sharing of presence information across cluster of servers (see broker relay config options).
  • Resolve user destinations across cluster of servers (see broker relay config options).
  • StompSubProtocolErrorHandlerextension point to customize and control STOMP ERROR frames to clients.
  • Global @MessageExceptionHandlermethods via @ControllerAdvicecomponents.
  • Heart-beats and a SpEL expression 'selector' header for subscriptions with SimpleBrokerMessageHandler.
  • STOMP client for use over TCP and WebSocket; see Section 26.4.13, “STOMP Client”.
  • @SendToand @SendToUsercan contain destination variable placeholders.
  • Jackson’s @JsonViewsupported for return values on @MessageMappingand @SubscribeMappingmethods.
  • ListenableFutureand CompletableFutureas return value types from @MessageMappingand @SubscribeMappingmethods.
  • MarshallingMessageConverterfor XML payloads.

5.6 Testing Improvements

  • JUnit-based integration tests can now be executed with JUnit rules instead of the SpringJUnit4ClassRunner. This allows Spring-based integration tests to be run with alternative runners like JUnit’s Parameterizedor third-party runners such as the MockitoJUnitRunner.

  • The Spring MVC Test framework now provides first-class support for HtmlUnit, including integration with Selenium’s WebDriver, allowing for page-based web application testing without the need to deploy to a Servlet container.

  • AopTestUtilsis a new testing utility that allows developers to obtain a reference to the underlying target object hidden behind one or more Spring proxies.

  • ReflectionTestUtilsnow supports setting and getting staticfields, including constants.
  • The original ordering of bean definition profiles declared via @ActiveProfilesis now retained in order to support use cases such as Spring Boot’s ConfigFileApplicationListenerwhich loads configuration files based on the names of active profiles.
  • @DirtiesContextsupports new BEFORE_METHOD, BEFORE_CLASS, and BEFORE_EACH_TEST_METHODmodes for closing the ApplicationContext beforea test — for example, if some rogue (i.e., yet to be determined) test within a large test suite has corrupted the original configuration for the ApplicationContext.
  • @Commitis a new annotation that may be used as a direct replacement for @Rollback(false).

  • @Rollbackmay now be used to configure class-level default rollbacksemantics.

    • Consequently, @TransactionConfigurationis now deprecated and will be removed in a subsequent release.
  • @Sqlnow supports execution of inlined SQL statementsvia a new statementsattribute.
  • The ContextCachethat is used for caching ApplicationContexts between tests is now a public API with a default implementation that can be replaced for custom caching needs.
  • DefaultTestContext, DefaultBootstrapContext, and DefaultCacheAwareContextLoaderDelegateare now public classes in the supportsubpackage, allowing for custom extensions.
  • TestContextBootstrappers are now responsible for building the TestContext.
  • In the Spring MVC Test framework, MvcResultdetails can now be logged at DEBUGlevel or written to a custom OutputStreamor Writer. See the new log(), print(OutputStream), and print(Writer)methods in MockMvcResultHandlersfor details.
  • The JDBC XML namespace supports a new database-nameattribute in <jdbc:embedded-database>, allowing developers to set unique names for embedded databases –- for example, via a SpEL expression or a property placeholder that is influenced by the current active bean definition profiles.

  • Embedded databases can now be automatically assigned a unique name, allowing common test database configuration to be reused in different ApplicationContexts within a test suite.

  • MockHttpServletRequestand MockHttpServletResponsenow provide better support for date header formatting via the getDateHeaderand setDateHeadermethods.

6. New Features and Enhancements in Spring Framework 4.3

6.1 Core Container Improvements

  • Core container exceptions provide richer metadata to evaluate programmatically.
  • Java 8 default methods get detected as bean property getters/setters.
  • Lazy candidate beans are not being created in case of injecting a primary bean.
  • It is no longer necessary to specify the @Autowiredannotation if the target bean only defines one constructor.
  • @Configurationclasses support constructor injection.
  • Any SpEL expression used to specify the conditionof an @EventListenercan now refer to beans (e.g. @beanName.method()).
  • Composed annotationscan now override array attributes in meta-annotations with a single element of the component type of the array. For example, the String[] pathattribute of @RequestMappingcan be overridden with String pathin a composed annotation.
  • @PersistenceContext/ @PersistenceUnitselects a primary EntityManagerFactorybean if declared as such.
  • @Scheduledand @Schedulesmay now be used as meta-annotationsto create custom composed annotationswith attribute overrides.
  • @Scheduledis properly supported on beans of any scope.

6.2 Data Access Improvements

  • jdbc:initialize-databaseand jdbc:embedded-databasesupport a configurable separator to be applied to each script.

6.3 Caching Improvements

Spring 4.3 allows concurrent calls on a given key to be synchronized so that the value is only computed once. This is an opt-in feature that should be enabled via the new syncattribute on @Cacheable. This features introduces a breaking change in the Cacheinterface as a get(Object key, Callable<T> valueLoader)method has been added.

Spring 4.3 also improves the caching abstraction as follows:

  • SpEL expressions in caches-related annotations can now refer to beans (i.e. @beanName.method()).
  • ConcurrentMapCacheManagerand ConcurrentMapCachenow support the serialization of cache entries via a new storeByValueattribute.
  • @Cacheable, @CacheEvict, @CachePut, and @Cachingmay now be used as meta-annotationsto create custom composed annotationswith attribute overrides.

6.4 JMS Improvements

  • @SendTocan now be specified at the class level to share a common reply destination.
  • @JmsListenerand @JmsListenersmay now be used as meta-annotationsto create custom composed annotationswith attribute overrides.

6.5 Web Improvements

  • Built-in support for HTTP HEAD and HTTP OPTIONS.

  • New @GetMapping, @PostMapping, @PutMapping, @DeleteMapping, and @PatchMapping composed annotationsfor @RequestMapping.

  • New @RequestScope, @SessionScope, and @ApplicationScope composed annotationsfor web scopes.

  • New @RestControllerAdviceannotation with combined @ControllerAdvicewith @ResponseBodysemantics.
  • @ResponseStatusis now supported at the class level and inherited by all methods.
  • New @SessionAttributeannotation for access to session attributes (see example).
  • New @RequestAttributeannotation for access to request attributes (see example).
  • @ModelAttributeallows preventing data binding via binding=falseattribute (see reference).
  • @PathVariablemay be declared as optional (for use on @ModelAttributemethods).
  • Consistent exposure of Errors and custom Throwables to MVC exception handlers.
  • Consistent charset handling in HTTP message converters, including a UTF-8 default for multipart text content.
  • Static resource handling uses the configured ContentNegotiationManagerfor media type determination.
  • RestTemplateand AsyncRestTemplatesupport strict URI variable encoding via DefaultUriTemplateHandler.
  • AsyncRestTemplatesupports request interception.

6.6 WebSocket Messaging Improvements

  • @SendToand @SendToUsercan now be specified at class-level to share a common destination.

6.7 Testing Improvements

  • The JUnit support in the Spring TestContext Frameworknow requires JUnit 4.12 or higher.
  • New SpringRunner aliasfor the SpringJUnit4ClassRunner.
  • Test related annotations may now be declared on interfaces — for example, for use with test interfacesthat make use of Java 8 based interface default methods.
  • An empty declaration of @ContextConfigurationcan now be completely omitted if default XML files, Groovy scripts, or @Configurationclasses are detected.
  • @Transactionaltest methods are no longer required to be public(e.g., in TestNG and JUnit 5).
  • @BeforeTransactionand @AfterTransactionmethods are no longer required to be publicand may now be declared on Java 8 based interface default methods.
  • The ApplicationContextcache in the Spring TestContext Frameworkis now bounded with a default maximum size of 32 and a least recently usedeviction policy. The maximum size can be configured by setting a JVM system property or Spring property called spring.test.context.cache.maxSize.
  • New ContextCustomizerAPI for customizing a test ApplicationContext afterbean definitions have been loaded into the context but beforethe context has been refreshed. Customizers can be registered globally by third parties, foregoing the need to implement a custom ContextLoader.
  • @Sqland @SqlGroupmay now be used as meta-annotationsto create custom composed annotationswith attribute overrides.
  • ReflectionTestUtilsnow automatically unwraps proxies when setting or getting a field.
  • Server-side Spring MVC Test supports expectations on response headers with multiple values.
  • Server-side Spring MVC Test parses form data request content and populates request parameters.
  • Server-side Spring MVC Test supports mock-like assertions for invoked handler methods.
  • Client-side REST test support allows indicating how many times a request is expected and whether the order of declaration for expectations should be ignored (see Section 15.6.3, “Client-Side REST Tests”).
  • Client-side REST Test supports expectations for form data in the request body.

6.8 Support for new library and server generations

  • Hibernate ORM 5.2 (still supporting 4.2/4.3 and 5.0/5.1 as well, with 3.6 deprecated now)
  • Hibernate Validator 5.3 (minimum remains at 4.3)
  • Jackson 2.8 (minimum raised to Jackson 2.6+ as of Spring 4.3)
  • OkHttp 3.x (still supporting OkHttp 2.x side by side)
  • Tomcat 8.5 as well as 9.0 milestones
  • Netty 4.1
  • Undertow 1.4
  • WildFly 10.1

Furthermore, Spring Framework 4.3 embeds the updated ASM 5.1, CGLIB 3.2.4, and Objenesis 2.4 in spring-core.jar.

Part III. Core Technologies

This part of the reference documentation covers all of those technologies that are absolutely integral to the Spring Framework.

Foremost amongst these is the Spring Framework’s Inversion of Control (IoC) container. A thorough treatment of the Spring Framework’s IoC container is closely followed by comprehensive coverage of Spring’s Aspect-Oriented Programming (AOP) technologies. The Spring Framework has its own AOP framework, which is conceptually easy to understand, and which successfully addresses the 80% sweet spot of AOP requirements in Java enterprise programming.

Coverage of Spring’s integration with AspectJ (currently the richest - in terms of features - and certainly most mature AOP implementation in the Java enterprise space) is also provided.

7. The IoC container

7.1 Introduction to the Spring IoC container and beans

This chapter covers the Spring Framework implementation of the Inversion of Control (IoC) [1]principle. IoC is also known as dependency injection(DI). It is a process whereby objects define their dependencies, that is, the other objects they work with, only through constructor arguments, arguments to a factory method, or properties that are set on the object instance after it is constructed or returned from a factory method. The container then injectsthose dependencies when it creates the bean. This process is fundamentally the inverse, hence the name Inversion of Control(IoC), of the bean itself controlling the instantiation or location of its dependencies by using direct construction of classes, or a mechanism such as the Service Locatorpattern.

The org.springframework.beansand org.springframework.contextpackages are the basis for Spring Framework’s IoC container. The BeanFactoryinterface provides an advanced configuration mechanism capable of managing any type of object. ApplicationContextis a sub-interface of BeanFactory. It adds easier integration with Spring’s AOP features; message resource handling (for use in internationalization), event publication; and application-layer specific contexts such as the WebApplicationContextfor use in web applications.

In short, the BeanFactoryprovides the configuration framework and basic functionality, and the ApplicationContextadds more enterprise-specific functionality. The ApplicationContextis a complete superset of the BeanFactory, and is used exclusively in this chapter in descriptions of Spring’s IoC container. For more information on using the BeanFactoryinstead of the ApplicationContext,refer to Section 7.16, “The BeanFactory”.

In Spring, the objects that form the backbone of your application and that are managed by the Spring IoC containerare called beans. A bean is an object that is instantiated, assembled, and otherwise managed by a Spring IoC container. Otherwise, a bean is simply one of many objects in your application. Beans, and the dependenciesamong them, are reflected in the configuration metadataused by a container.

7.2 Container overview

The interface org.springframework.context.ApplicationContextrepresents the Spring IoC container and is responsible for instantiating, configuring, and assembling the aforementioned beans. The container gets its instructions on what objects to instantiate, configure, and assemble by reading configuration metadata. The configuration metadata is represented in XML, Java annotations, or Java code. It allows you to express the objects that compose your application and the rich interdependencies between such objects.

Several implementations of the ApplicationContextinterface are supplied out-of-the-box with Spring. In standalone applications it is common to create an instance of ClassPathXmlApplicationContextor FileSystemXmlApplicationContext. While XML has been the traditional format for defining configuration metadata you can instruct the container to use Java annotations or code as the metadata format by providing a small amount of XML configuration to declaratively enable support for these additional metadata formats.

In most application scenarios, explicit user code is not required to instantiate one or more instances of a Spring IoC container. For example, in a web application scenario, a simple eight (or so) lines of boilerplate web descriptor XML in the web.xmlfile of the application will typically suffice (see Section 7.15.4, “Convenient ApplicationContext instantiation for web applications”). If you are using the Spring Tool SuiteEclipse-powered development environment this boilerplate configuration can be easily created with few mouse clicks or keystrokes.

The following diagram is a high-level view of how Spring works. Your application classes are combined with configuration metadata so that after the ApplicationContextis created and initialized, you have a fully configured and executable system or application.

Figure 7.1. The Spring IoC container

container magic

7.2.1 Configuration metadata

As the preceding diagram shows, the Spring IoC container consumes a form of configuration metadata; this configuration metadata represents how you as an application developer tell the Spring container to instantiate, configure, and assemble the objects in your application.

Configuration metadata is traditionally supplied in a simple and intuitive XML format, which is what most of this chapter uses to convey key concepts and features of the Spring IoC container.

[Note] Note

XML-based metadata is notthe only allowed form of configuration metadata. The Spring IoC container itself is totallydecoupled from the format in which this configuration metadata is actually written. These days many developers choose Java-based configurationfor their Spring applications.

For information about using other forms of metadata with the Spring container, see:

  • Annotation-based configuration: Spring 2.5 introduced support for annotation-based configuration metadata.
  • Java-based configuration: Starting with Spring 3.0, many features provided by the Spring JavaConfig project became part of the core Spring Framework. Thus you can define beans external to your application classes by using Java rather than XML files. To use these new features, see the @Configuration, @Bean, @Importand @DependsOnannotations.

Spring configuration consists of at least one and typically more than one bean definition that the container must manage. XML-based configuration metadata shows these beans configured as <bean/>elements inside a top-level <beans/>element. Java configuration typically uses @Beanannotated methods within a @Configurationclass.

These bean definitions correspond to the actual objects that make up your application. Typically you define service layer objects, data access objects (DAOs), presentation objects such as Struts Actioninstances, infrastructure objects such as Hibernate SessionFactories, JMS Queues, and so forth. Typically one does not configure fine-grained domain objects in the container, because it is usually the responsibility of DAOs and business logic to create and load domain objects. However, you can use Spring’s integration with AspectJ to configure objects that have been created outside the control of an IoC container. See Using AspectJ to dependency-inject domain objects with Spring.

The following example shows the basic structure of XML-based configuration metadata:

								<?xml version="1.0" encoding="UTF-8"?>
								<beans
								xmlns=
								"http://www.springframework.org/schema/beans"
								xmlns:xsi=
								"http://www.w3.org/2001/XMLSchema-instance"
								xsi:schemaLocation=
								"http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd"
								>
								<bean
								id=
								"..."
								class=
								"..."
								>
								<!-- collaborators and configuration for this bean go here -->
								</bean>
								<bean
								id=
								"..."
								class=
								"..."
								>
								<!-- collaborators and configuration for this bean go here -->
								</bean>
								<!-- more bean definitions go here -->
								</beans>

The idattribute is a string that you use to identify the individual bean definition. The classattribute defines the type of the bean and uses the fully qualified classname. The value of the id attribute refers to collaborating objects. The XML for referring to collaborating objects is not shown in this example; see Dependenciesfor more information.

7.2.2 Instantiating a container

Instantiating a Spring IoC container is straightforward. The location path or paths supplied to an ApplicationContextconstructor are actually resource strings that allow the container to load configuration metadata from a variety of external resources such as the local file system, from the Java CLASSPATH, and so on.

ApplicationContext context =
								newClassPathXmlApplicationContext(
								newString[] {
								"services.xml",
								"daos.xml"});
[Note] Note

After you learn about Spring’s IoC container, you may want to know more about Spring’s Resourceabstraction, as described in Chapter 8, Resources , which provides a convenient mechanism for reading an InputStream from locations defined in a URI syntax. In particular, Resourcepaths are used to construct applications contexts as described in Section 8.7, “Application contexts and Resource paths”.

The following example shows the service layer objects (services.xml)configuration file:

								<?xml version="1.0" encoding="UTF-8"?>
								<beans
								xmlns=
								"http://www.springframework.org/schema/beans"
								xmlns:xsi=
								"http://www.w3.org/2001/XMLSchema-instance"
								xsi:schemaLocation=
								"http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd"
								>
								<!-- services -->
								<bean
								id=
								"petStore"
								class=
								"org.springframework.samples.jpetstore.services.PetStoreServiceImpl"
								>
								<property
								name=
								"accountDao"
								ref=
								"accountDao"
								/>
								<property
								name=
								"itemDao"
								ref=
								"itemDao"
								/>
								<!-- additional collaborators and configuration for this bean go here -->
								</bean>
								<!-- more bean definitions for services go here -->
								</beans>

The following example shows the data access objects daos.xmlfile:

								<?xml version="1.0" encoding="UTF-8"?>
								<beans
								xmlns=
								"http://www.springframework.org/schema/beans"
								xmlns:xsi=
								"http://www.w3.org/2001/XMLSchema-instance"
								xsi:schemaLocation=
								"http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd"
								>
								<bean
								id=
								"accountDao"
								class=
								"org.springframework.samples.jpetstore.dao.jpa.JpaAccountDao"
								>
								<!-- additional collaborators and configuration for this bean go here -->
								</bean>
								<bean
								id=
								"itemDao"
								class=
								"org.springframework.samples.jpetstore.dao.jpa.JpaItemDao"
								>
								<!-- additional collaborators and configuration for this bean go here -->
								</bean>
								<!-- more bean definitions for data access objects go here -->
								</beans>

In the preceding example, the service layer consists of the class PetStoreServiceImpl, and two data access objects of the type JpaAccountDaoand JpaItemDao(based on the JPA Object/Relational mapping standard). The property nameelement refers to the name of the JavaBean property, and the refelement refers to the name of another bean definition. This linkage between idand refelements expresses the dependency between collaborating objects. For details of configuring an object’s dependencies, see Dependencies.

Composing XML-based configuration metadata

It can be useful to have bean definitions span multiple XML files. Often each individual XML configuration file represents a logical layer or module in your architecture.

You can use the application context constructor to load bean definitions from all these XML fragments. This constructor takes multiple Resourcelocations, as was shown in the previous section. Alternatively, use one or more occurrences of the <import/>element to load bean definitions from another file or files. For example:

									<beans>
									<import
									resource=
									"services.xml"
									/>
									<import
									resource=
									"resources/messageSource.xml"
									/>
									<import
									resource=
									"/resources/themeSource.xml"
									/>
									<bean
									id=
									"bean1"
									class=
									"..."
									/>
									<bean
									id=
									"bean2"
									class=
									"..."
									/>
									</beans>

In the preceding example, external bean definitions are loaded from three files: services.xml, messageSource.xml, and themeSource.xml. All location paths are relative to the definition file doing the importing, so services.xmlmust be in the same directory or classpath location as the file doing the importing, while messageSource.xmland themeSource.xmlmust be in a resourceslocation below the location of the importing file. As you can see, a leading slash is ignored, but given that these paths are relative, it is better form not to use the slash at all. The contents of the files being imported, including the top level <beans/>element, must be valid XML bean definitions according to the Spring Schema.

[Note] Note

It is possible, but not recommended, to reference files in parent directories using a relative "../" path. Doing so creates a dependency on a file that is outside the current application. In particular, this reference is not recommended for "classpath:" URLs (for example, "classpath:../services.xml"), where the runtime resolution process chooses the "nearest" classpath root and then looks into its parent directory. Classpath configuration changes may lead to the choice of a different, incorrect directory.

You can always use fully qualified resource locations instead of relative paths: for example, "file:C:/config/services.xml" or "classpath:/config/services.xml". However, be aware that you are coupling your application’s configuration to specific absolute locations. It is generally preferable to keep an indirection for such absolute locations, for example, through "${…​}" placeholders that are resolved against JVM system properties at runtime.

7.2.3 Using the container

The ApplicationContextis the interface for an advanced factory capable of maintaining a registry of different beans and their dependencies. Using the method T getBean(String name, Class<T> requiredType)you can retrieve instances of your beans.

The ApplicationContextenables you to read bean definitions and access them as follows:

								// create and configure beansApplicationContext context =
								newClassPathXmlApplicationContext(
								newString[] {
								"services.xml",
								"daos.xml"});
								// retrieve configured instancePetStoreService service = context.getBean(
								"petStore", PetStoreService.
								class);
								// use configured instanceList<String> userList = service.getUsernameList();

You use getBean()to retrieve instances of your beans. The ApplicationContextinterface has a few other methods for retrieving beans, but ideally your application code should never use them. Indeed, your application code should have no calls to the getBean()method at all, and thus no dependency on Spring APIs at all. For example, Spring’s integration with web frameworks provides for dependency injection for various web framework classes such as controllers and JSF-managed beans.

7.3 Bean overview

A Spring IoC container manages one or more beans. These beans are created with the configuration metadata that you supply to the container, for example, in the form of XML <bean/>definitions.

Within the container itself, these bean definitions are represented as BeanDefinitionobjects, which contain (among other information) the following metadata:

  • A package-qualified class name:typically the actual implementation class of the bean being defined.
  • Bean behavioral configuration elements, which state how the bean should behave in the container (scope, lifecycle callbacks, and so forth).
  • References to other beans that are needed for the bean to do its work; these references are also called collaboratorsor dependencies.
  • Other configuration settings to set in the newly created object, for example, the number of connections to use in a bean that manages a connection pool, or the size limit of the pool.

This metadata translates to a set of properties that make up each bean definition.

Table 7.1. The bean definition

Property Explained in…​

class

Section 7.3.2, “Instantiating beans”

name

Section 7.3.1, “Naming beans”

scope

Section 7.5, “Bean scopes”

constructor arguments

Section 7.4.1, “Dependency Injection”

properties

Section 7.4.1, “Dependency Injection”

autowiring mode

Section 7.4.5, “Autowiring collaborators”

lazy-initialization mode

Section 7.4.4, “Lazy-initialized beans”

initialization method

the section called “Initialization callbacks”

destruction method

the section called “Destruction callbacks”

In addition to bean definitions that contain information on how to create a specific bean, the ApplicationContextimplementations also permit the registration of existing objects that are created outside the container, by users. This is done by accessing the ApplicationContext’s BeanFactory via the method getBeanFactory()which returns the BeanFactory implementation DefaultListableBeanFactory. DefaultListableBeanFactorysupports this registration through the methods registerSingleton(..)and registerBeanDefinition(..). However, typical applications work solely with beans defined through metadata bean definitions.

[Note] Note

Bean metadata and manually supplied singleton instances need to be registered as early as possible, in order for the container to properly reason about them during autowiring and other introspection steps. While overriding of existing metadata and existing singleton instances is supported to some degree, the registration of new beans at runtime (concurrently with live access to factory) is not officially supported and may lead to concurrent access exceptions and/or inconsistent state in the bean container.

7.3.1 Naming beans

Every bean has one or more identifiers. These identifiers must be unique within the container that hosts the bean. A bean usually has only one identifier, but if it requires more than one, the extra ones can be considered aliases.

In XML-based configuration metadata, you use the idand/or nameattributes to specify the bean identifier(s). The idattribute allows you to specify exactly one id. Conventionally these names are alphanumeric ('myBean', 'fooService', etc.), but may contain special characters as well. If you want to introduce other aliases to the bean, you can also specify them in the nameattribute, separated by a comma ( ,), semicolon ( ;), or white space. As a historical note, in versions prior to Spring 3.1, the idattribute was defined as an xsd:IDtype, which constrained possible characters. As of 3.1, it is defined as an xsd:stringtype. Note that bean iduniqueness is still enforced by the container, though no longer by XML parsers.

You are not required to supply a name or id for a bean. If no name or id is supplied explicitly, the container generates a unique name for that bean. However, if you want to refer to that bean by name, through the use of the refelement or Service Locatorstyle lookup, you must provide a name. Motivations for not supplying a name are related to using inner beansand autowiring collaborators.

Bean Naming Conventions

The convention is to use the standard Java convention for instance field names when naming beans. That is, bean names start with a lowercase letter, and are camel-cased from then on. Examples of such names would be (without quotes) 'accountManager', 'accountService', 'userDao', 'loginController', and so forth.

Naming beans consistently makes your configuration easier to read and understand, and if you are using Spring AOP it helps a lot when applying advice to a set of beans related by name.

[Note] Note

With component scanning in the classpath, Spring generates bean names for unnamed components, following the rules above: essentially, taking the simple class name and turning its initial character to lower-case. However, in the (unusual) special case when there is more than one character and both the first and second characters are upper case, the original casing gets preserved. These are the same rules as defined by java.beans.Introspector.decapitalize(which Spring is using here).

Aliasing a bean outside the bean definition

In a bean definition itself, you can supply more than one name for the bean, by using a combination of up to one name specified by the idattribute, and any number of other names in the nameattribute. These names can be equivalent aliases to the same bean, and are useful for some situations, such as allowing each component in an application to refer to a common dependency by using a bean name that is specific to that component itself.

Specifying all aliases where the bean is actually defined is not always adequate, however. It is sometimes desirable to introduce an alias for a bean that is defined elsewhere. This is commonly the case in large systems where configuration is split amongst each subsystem, each subsystem having its own set of object definitions. In XML-based configuration metadata, you can use the <alias/>element to accomplish this.

									<alias
									name=
									"fromName"
									alias=
									"toName"
									/>

In this case, a bean in the same container which is named fromName, may also, after the use of this alias definition, be referred to as toName.

For example, the configuration metadata for subsystem A may refer to a DataSource via the name subsystemA-dataSource. The configuration metadata for subsystem B may refer to a DataSource via the name subsystemB-dataSource. When composing the main application that uses both these subsystems the main application refers to the DataSource via the name myApp-dataSource. To have all three names refer to the same object you add to the MyApp configuration metadata the following aliases definitions:

									<alias
									name=
									"subsystemA-dataSource"
									alias=
									"subsystemB-dataSource"
									/>
									<alias
									name=
									"subsystemA-dataSource"
									alias=
									"myApp-dataSource"
									/>

Now each component and the main application can refer to the dataSource through a name that is unique and guaranteed not to clash with any other definition (effectively creating a namespace), yet they refer to the same bean.

Java-configuration

If you are using Java-configuration, the @Beanannotation can be used to provide aliases see Section 7.12.3, “Using the @Bean annotation”for details.

7.3.2 Instantiating beans

A bean definition essentially is a recipe for creating one or more objects. The container looks at the recipe for a named bean when asked, and uses the configuration metadata encapsulated by that bean definition to create (or acquire) an actual object.

If you use XML-based configuration metadata, you specify the type (or class) of object that is to be instantiated in the classattribute of the <bean/>element. This classattribute, which internally is a Classproperty on a BeanDefinitioninstance, is usually mandatory. (For exceptions, see the section called “Instantiation using an instance factory method”and Section 7.7, “Bean definition inheritance”.) You use the Classproperty in one of two ways:

  • Typically, to specify the bean class to be constructed in the case where the container itself directly creates the bean by calling its constructor reflectively, somewhat equivalent to Java code using the newoperator.
  • To specify the actual class containing the staticfactory method that will be invoked to create the object, in the less common case where the container invokes a static factorymethod on a class to create the bean. The object type returned from the invocation of the staticfactory method may be the same class or another class entirely.

Inner class names. If you want to configure a bean definition for a staticnested class, you have to use the binaryname of the nested class.

For example, if you have a class called Fooin the com.examplepackage, and this Fooclass has a staticnested class called Bar, the value of the 'class'attribute on a bean definition would be…​

com.example.Foo$Bar

Notice the use of the $character in the name to separate the nested class name from the outer class name.

Instantiation with a constructor

When you create a bean by the constructor approach, all normal classes are usable by and compatible with Spring. That is, the class being developed does not need to implement any specific interfaces or to be coded in a specific fashion. Simply specifying the bean class should suffice. However, depending on what type of IoC you use for that specific bean, you may need a default (empty) constructor.

The Spring IoC container can manage virtually anyclass you want it to manage; it is not limited to managing true JavaBeans. Most Spring users prefer actual JavaBeans with only a default (no-argument) constructor and appropriate setters and getters modeled after the properties in the container. You can also have more exotic non-bean-style classes in your container. If, for example, you need to use a legacy connection pool that absolutely does not adhere to the JavaBean specification, Spring can manage it as well.

With XML-based configuration metadata you can specify your bean class as follows:

									<bean
									id=
									"exampleBean"
									class=
									"examples.ExampleBean"
									/>
									<bean
									name=
									"anotherExample"
									class=
									"examples.ExampleBeanTwo"
									/>

For details about the mechanism for supplying arguments to the constructor (if required) and setting object instance properties after the object is constructed, see Injecting Dependencies.

Instantiation with a static factory method

When defining a bean that you create with a static factory method, you use the classattribute to specify the class containing the staticfactory method and an attribute named factory-methodto specify the name of the factory method itself. You should be able to call this method (with optional arguments as described later) and return a live object, which subsequently is treated as if it had been created through a constructor. One use for such a bean definition is to call staticfactories in legacy code.

The following bean definition specifies that the bean will be created by calling a factory-method. The definition does not specify the type (class) of the returned object, only the class containing the factory method. In this example, the createInstance()method must be a staticmethod.

									<bean
									id=
									"clientService"
									class=
									"examples.ClientService"
									factory-method=
									"createInstance"
									/>
									public
									classClientService {
									private
									staticClientService clientService =
									newClientService();
									privateClientService() {}
									public
									staticClientService createInstance() {
									returnclientService; } }

For details about the mechanism for supplying (optional) arguments to the factory method and setting object instance properties after the object is returned from the factory, see Dependencies and configuration in detail.

Instantiation using an instance factory method

Similar to instantiation through a static factory method, instantiation with an instance factory method invokes a non-static method of an existing bean from the container to create a new bean. To use this mechanism, leave the classattribute empty, and in the factory-beanattribute, specify the name of a bean in the current (or parent/ancestor) container that contains the instance method that is to be invoked to create the object. Set the name of the factory method itself with the factory-methodattribute.

									<!-- the factory bean, which contains a method called createInstance() -->
									<bean
									id=
									"serviceLocator"
									class=
									"examples.DefaultServiceLocator"
									>
									<!-- inject any dependencies required by this locator bean -->
									</bean>
									<!-- the bean to be created via the factory bean -->
									<bean
									id=
									"clientService"
									factory-bean=
									"serviceLocator"
									factory-method=
									"createClientServiceInstance"
									/>
									public
									classDefaultServiceLocator {
									private
									staticClientService clientService =
									newClientServiceImpl();
									privateDefaultServiceLocator() {}
									publicClientService createClientServiceInstance() {
									returnclientService; } }

One factory class can also hold more than one factory method as shown here:

									<bean
									id=
									"serviceLocator"
									class=
									"examples.DefaultServiceLocator"
									>
									<!-- inject any dependencies required by this locator bean -->
									</bean>
									<bean
									id=
									"clientService"
									factory-bean=
									"serviceLocator"
									factory-method=
									"createClientServiceInstance"
									/>
									<bean
									id=
									"accountService"
									factory-bean=
									"serviceLocator"
									factory-method=
									"createAccountServiceInstance"
									/>
									public
									classDefaultServiceLocator {
									private
									staticClientService clientService =
									newClientServiceImpl();
									private
									staticAccountService accountService =
									newAccountServiceImpl();
									privateDefaultServiceLocator() {}
									publicClientService createClientServiceInstance() {
									returnclientService; }
									publicAccountService createAccountServiceInstance() {
									returnaccountService; } }

This approach shows that the factory bean itself can be managed and configured through dependency injection (DI). See Dependencies and configuration in detail.

[Note] Note

In Spring documentation, factory beanrefers to a bean that is configured in the Spring container that will create objects through an instanceor staticfactory method. By contrast, FactoryBean(notice the capitalization) refers to a Spring-specific FactoryBean.

7.4 Dependencies

A typical enterprise application does not consist of a single object (or bean in the Spring parlance). Even the simplest application has a few objects that work together to present what the end-user sees as a coherent application. This next section explains how you go from defining a number of bean definitions that stand alone to a fully realized application where objects collaborate to achieve a goal.

7.4.1 Dependency Injection

Dependency injection(DI) is a process whereby objects define their dependencies, that is, the other objects they work with, only through constructor arguments, arguments to a factory method, or properties that are set on the object instance after it is constructed or returned from a factory method. The container then injectsthose dependencies when it creates the bean. This process is fundamentally the inverse, hence the name Inversion of Control(IoC), of the bean itself controlling the instantiation or location of its dependencies on its own by using direct construction of classes, or the Service Locatorpattern.

Code is cleaner with the DI principle and decoupling is more effective when objects are provided with their dependencies. The object does not look up its dependencies, and does not know the location or class of the dependencies. As such, your classes become easier to test, in particular when the dependencies are on interfaces or abstract base classes, which allow for stub or mock implementations to be used in unit tests.

DI exists in two major variants, Constructor-based dependency injectionand Setter-based dependency injection.

Constructor-based dependency injection

Constructor-basedDI is accomplished by the container invoking a constructor with a number of arguments, each representing a dependency. Calling a staticfactory method with specific arguments to construct the bean is nearly equivalent, and this discussion treats arguments to a constructor and to a staticfactory method similarly. The following example shows a class that can only be dependency-injected with constructor injection. Notice that there is nothing specialabout this class, it is a POJO that has no dependencies on container specific interfaces, base classes or annotations.

									public
									classSimpleMovieLister {
									// the SimpleMovieLister has a dependency on a MovieFinder
									privateMovieFinder movieFinder;
									// a constructor so that the Spring container can inject a MovieFinder
									publicSimpleMovieLister(MovieFinder movieFinder) {
									this.movieFinder = movieFinder; }
									// business logic that actually uses the injected MovieFinder is omitted...}
Constructor argument resolution

Constructor argument resolution matching occurs using the argument’s type. If no potential ambiguity exists in the constructor arguments of a bean definition, then the order in which the constructor arguments are defined in a bean definition is the order in which those arguments are supplied to the appropriate constructor when the bean is being instantiated. Consider the following class:

										packagex.y;
										public
										classFoo {
										publicFoo(Bar bar, Baz baz) {
										// ...} }

No potential ambiguity exists, assuming that Barand Bazclasses are not related by inheritance. Thus the following configuration works fine, and you do not need to specify the constructor argument indexes and/or types explicitly in the <constructor-arg/>element.

										<beans>
										<bean
										id=
										"foo"
										class=
										"x.y.Foo"
										>
										<constructor-arg
										ref=
										"bar"
										/>
										<constructor-arg
										ref=
										"baz"
										/>
										</bean>
										<bean
										id=
										"bar"
										class=
										"x.y.Bar"
										/>
										<bean
										id=
										"baz"
										class=
										"x.y.Baz"
										/>
										</beans>

When another bean is referenced, the type is known, and matching can occur (as was the case with the preceding example). When a simple type is used, such as <value>true</value>, Spring cannot determine the type of the value, and so cannot match by type without help. Consider the following class:

										packageexamples;
										public
										classExampleBean {
										// Number of years to calculate the Ultimate Answer
										private
										intyears;
										// The Answer to Life, the Universe, and Everything
										privateString ultimateAnswer;
										publicExampleBean(
										intyears, String ultimateAnswer) {
										this.years = years;
										this.ultimateAnswer = ultimateAnswer; } }

In the preceding scenario, the container canuse type matching with simple types if you explicitly specify the type of the constructor argument using the typeattribute. For example:

										<bean
										id=
										"exampleBean"
										class=
										"examples.ExampleBean"
										>
										<constructor-arg
										type=
										"int"
										value=
										"7500000"
										/>
										<constructor-arg
										type=
										"java.lang.String"
										value=
										"42"
										/>
										</bean>

Use the indexattribute to specify explicitly the index of constructor arguments. For example:

										<bean
										id=
										"exampleBean"
										class=
										"examples.ExampleBean"
										>
										<constructor-arg
										index=
										"0"
										value=
										"7500000"
										/>
										<constructor-arg
										index=
										"1"
										value=
										"42"
										/>
										</bean>

In addition to resolving the ambiguity of multiple simple values, specifying an index resolves ambiguity where a constructor has two arguments of the same type. Note that the index is 0 based.

You can also use the constructor parameter name for value disambiguation:

										<bean
										id=
										"exampleBean"
										class=
										"examples.ExampleBean"
										>
										<constructor-arg
										name=
										"years"
										value=
										"7500000"
										/>
										<constructor-arg
										name=
										"ultimateAnswer"
										value=
										"42"
										/>
										</bean>

Keep in mind that to make this work out of the box your code must be compiled with the debug flag enabled so that Spring can look up the parameter name from the constructor. If you can’t compile your code with debug flag (or don’t want to) you can use @ConstructorPropertiesJDK annotation to explicitly name your constructor arguments. The sample class would then have to look as follows:

										packageexamples;
										public
										classExampleBean {
										// Fields omitted
										
											@ConstructorProperties({"years", "ultimateAnswer"})
										publicExampleBean(
										intyears, String ultimateAnswer) {
										this.years = years;
										this.ultimateAnswer = ultimateAnswer; } }

Setter-based dependency injection

Setter-basedDI is accomplished by the container calling setter methods on your beans after invoking a no-argument constructor or no-argument staticfactory method to instantiate your bean.

The following example shows a class that can only be dependency-injected using pure setter injection. This class is conventional Java. It is a POJO that has no dependencies on container specific interfaces, base classes or annotations.

									public
									classSimpleMovieLister {
									// the SimpleMovieLister has a dependency on the MovieFinder
									privateMovieFinder movieFinder;
									// a setter method so that the Spring container can inject a MovieFinder
									public
									voidsetMovieFinder(MovieFinder movieFinder) {
									this.movieFinder = movieFinder; }
									// business logic that actually uses the injected MovieFinder is omitted...}

The ApplicationContextsupports constructor-based and setter-based DI for the beans it manages. It also supports setter-based DI after some dependencies have already been injected through the constructor approach. You configure the dependencies in the form of a BeanDefinition, which you use in conjunction with PropertyEditorinstances to convert properties from one format to another. However, most Spring users do not work with these classes directly (i.e., programmatically) but rather with XML beandefinitions, annotated components (i.e., classes annotated with @Component, @Controller, etc.), or @Beanmethods in Java-based @Configurationclasses. These sources are then converted internally into instances of BeanDefinitionand used to load an entire Spring IoC container instance.

Constructor-based or setter-based DI?

Since you can mix constructor-based and setter-based DI, it is a good rule of thumb to use constructors for mandatory dependenciesand setter methods or configuration methods for optional dependencies. Note that use of the @Requiredannotation on a setter method can be used to make the property a required dependency.

The Spring team generally advocates constructor injection as it enables one to implement application components as immutable objectsand to ensure that required dependencies are not null. Furthermore constructor-injected components are always returned to client (calling) code in a fully initialized state. As a side note, a large number of constructor arguments is a bad code smell, implying that the class likely has too many responsibilities and should be refactored to better address proper separation of concerns.

Setter injection should primarily only be used for optional dependencies that can be assigned reasonable default values within the class. Otherwise, not-null checks must be performed everywhere the code uses the dependency. One benefit of setter injection is that setter methods make objects of that class amenable to reconfiguration or re-injection later. Management through JMX MBeansis therefore a compelling use case for setter injection.

Use the DI style that makes the most sense for a particular class. Sometimes, when dealing with third-party classes for which you do not have the source, the choice is made for you. For example, if a third-party class does not expose any setter methods, then constructor injection may be the only available form of DI.

Dependency resolution process

The container performs bean dependency resolution as follows:

  • The ApplicationContextis created and initialized with configuration metadata that describes all the beans. Configuration metadata can be specified via XML, Java code, or annotations.
  • For each bean, its dependencies are expressed in the form of properties, constructor arguments, or arguments to the static-factory method if you are using that instead of a normal constructor. These dependencies are provided to the bean, when the bean is actually created.
  • Each property or constructor argument is an actual definition of the value to set, or a reference to another bean in the container.
  • Each property or constructor argument which is a value is converted from its specified format to the actual type of that property or constructor argument. By default Spring can convert a value supplied in string format to all built-in types, such as int, long, String, boolean, etc.

The Spring container validates the configuration of each bean as the container is created. However, the bean properties themselves are not set until the bean is actually created. Beans that are singleton-scoped and set to be pre-instantiated (the default) are created when the container is created. Scopes are defined in Section 7.5, “Bean scopes”. Otherwise, the bean is created only when it is requested. Creation of a bean potentially causes a graph of beans to be created, as the bean’s dependencies and its dependencies' dependencies (and so on) are created and assigned. Note that resolution mismatches among those dependencies may show up late, i.e. on first creation of the affected bean.

Circular dependencies

If you use predominantly constructor injection, it is possible to create an unresolvable circular dependency scenario.

For example: Class A requires an instance of class B through constructor injection, and class B requires an instance of class A through constructor injection. If you configure beans for classes A and B to be injected into each other, the Spring IoC container detects this circular reference at runtime, and throws a BeanCurrentlyInCreationException.

One possible solution is to edit the source code of some classes to be configured by setters rather than constructors. Alternatively, avoid constructor injection and use setter injection only. In other words, although it is not recommended, you can configure circular dependencies with setter injection.

Unlike the typicalcase (with no circular dependencies), a circular dependency between bean A and bean B forces one of the beans to be injected into the other prior to being fully initialized itself (a classic chicken/egg scenario).

You can generally trust Spring to do the right thing. It detects configuration problems, such as references to non-existent beans and circular dependencies, at container load-time. Spring sets properties and resolves dependencies as late as possible, when the bean is actually created. This means that a Spring container which has loaded correctly can later generate an exception when you request an object if there is a problem creating that object or one of its dependencies. For example, the bean throws an exception as a result of a missing or invalid property. This potentially delayed visibility of some configuration issues is why ApplicationContextimplementations by default pre-instantiate singleton beans. At the cost of some upfront time and memory to create these beans before they are actually needed, you discover configuration issues when the ApplicationContextis created, not later. You can still override this default behavior so that singleton beans will lazy-initialize, rather than be pre-instantiated.

If no circular dependencies exist, when one or more collaborating beans are being injected into a dependent bean, each collaborating bean is totallyconfigured prior to being injected into the dependent bean. This means that if bean A has a dependency on bean B, the Spring IoC container completely configures bean B prior to invoking the setter method on bean A. In other words, the bean is instantiated (if not a pre-instantiated singleton), its dependencies are set, and the relevant lifecycle methods (such as a configured init methodor the InitializingBean callback method) are invoked.

Examples of dependency injection

The following example uses XML-based configuration metadata for setter-based DI. A small part of a Spring XML configuration file specifies some bean definitions:

									<bean
									id=
									"exampleBean"
									class=
									"examples.ExampleBean"
									>
									<!-- setter injection using the nested ref element -->
									<property
									name=
									"beanOne"
									>
									<ref
									bean=
									"anotherExampleBean"
									/>
									</property>
									<!-- setter injection using the neater ref attribute -->
									<property
									name=
									"beanTwo"
									ref=
									"yetAnotherBean"
									/>
									<property
									name=
									"integerProperty"
									value=
									"1"
									/>
									</bean>
									<bean
									id=
									"anotherExampleBean"
									class=
									"examples.AnotherBean"
									/>
									<bean
									id=
									"yetAnotherBean"
									class=
									"examples.YetAnotherBean"
									/>
									public
									classExampleBean {
									privateAnotherBean beanOne;
									privateYetAnotherBean beanTwo;
									private
									inti;
									public
									voidsetBeanOne(AnotherBean beanOne) {
									this.beanOne = beanOne; }
									public
									voidsetBeanTwo(YetAnotherBean beanTwo) {
									this.beanTwo = beanTwo; }
									public
									voidsetIntegerProperty(
									inti) {
									this.i = i; } }

In the preceding example, setters are declared to match against the properties specified in the XML file. The following example uses constructor-based DI:

									<bean
									id=
									"exampleBean"
									class=
									"examples.ExampleBean"
									>
									<!-- constructor injection using the nested ref element -->
									<constructor-arg>
									<ref
									bean=
									"anotherExampleBean"
									/>
									</constructor-arg>
									<!-- constructor injection using the neater ref attribute -->
									<constructor-arg
									ref=
									"yetAnotherBean"
									/>
									<constructor-arg
									type=
									"int"
									value=
									"1"
									/>
									</bean>
									<bean
									id=
									"anotherExampleBean"
									class=
									"examples.AnotherBean"
									/>
									<bean
									id=
									"yetAnotherBean"
									class=
									"examples.YetAnotherBean"
									/>
									public
									classExampleBean {
									privateAnotherBean beanOne;
									privateYetAnotherBean beanTwo;
									private
									inti;
									publicExampleBean( AnotherBean anotherBean, YetAnotherBean yetAnotherBean,
									inti) {
									this.beanOne = anotherBean;
									this.beanTwo = yetAnotherBean;
									this.i = i; } }

The constructor arguments specified in the bean definition will be used as arguments to the constructor of the ExampleBean.

Now consider a variant of this example, where instead of using a constructor, Spring is told to call a staticfactory method to return an instance of the object:

									<bean
									id=
									"exampleBean"
									class=
									"examples.ExampleBean"
									factory-method=
									"createInstance"
									>
									<constructor-arg
									ref=
									"anotherExampleBean"
									/>
									<constructor-arg
									ref=
									"yetAnotherBean"
									/>
									<constructor-arg
									value=
									"1"
									/>
									</bean>
									<bean
									id=
									"anotherExampleBean"
									class=
									"examples.AnotherBean"
									/>
									<bean
									id=
									"yetAnotherBean"
									class=
									"examples.YetAnotherBean"
									/>
									public
									classExampleBean {
									// a private constructor
									privateExampleBean(...) { ... }
									// a static factory method; the arguments to this method can be
									// considered the dependencies of the bean that is returned,
									// regardless of how those arguments are actually used.
									public
									staticExampleBean createInstance ( AnotherBean anotherBean, YetAnotherBean yetAnotherBean,
									inti) { ExampleBean eb =
									newExampleBean (...);
									// some other operations...
									returneb; } }

Arguments to the staticfactory method are supplied via <constructor-arg/>elements, exactly the same as if a constructor had actually been used. The type of the class being returned by the factory method does not have to be of the same type as the class that contains the staticfactory method, although in this example it is. An instance (non-static) factory method would be used in an essentially identical fashion (aside from the use of the factory-beanattribute instead of the classattribute), so details will not be discussed here.

7.4.2 Dependencies and configuration in detail

As mentioned in the previous section, you can define bean properties and constructor arguments as references to other managed beans (collaborators), or as values defined inline. Spring’s XML-based configuration metadata supports sub-element types within its <property/>and <constructor-arg/>elements for this purpose.

Straight values (primitives, Strings, and so on)

The valueattribute of the <property/>element specifies a property or constructor argument as a human-readable string representation. Spring’s conversion serviceis used to convert these values from a Stringto the actual type of the property or argument.

									<bean
									id=
									"myDataSource"
									class=
									"org.apache.commons.dbcp.BasicDataSource"
									destroy-method=
									"close"
									>
									<!-- results in a setDriverClassName(String) call -->
									<property
									name=
									"driverClassName"
									value=
									"com.mysql.jdbc.Driver"
									/>
									<property
									name=
									"url"
									value=
									"jdbc:mysql://localhost:3306/mydb"
									/>
									<property
									name=
									"username"
									value=
									"root"
									/>
									<property
									name=
									"password"
									value=
									"masterkaoli"
									/>
									</bean>

The following example uses the p-namespacefor even more succinct XML configuration.

									<beans
									xmlns=
									"http://www.springframework.org/schema/beans"
									xmlns:xsi=
									"http://www.w3.org/2001/XMLSchema-instance"
									xmlns:p=
									"http://www.springframework.org/schema/p"
									xsi:schemaLocation=
									"http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd"
									>
									<bean
									id=
									"myDataSource"
									class=
									"org.apache.commons.dbcp.BasicDataSource"
									destroy-method=
									"close"
									p:driverClassName=
									"com.mysql.jdbc.Driver"
									p:url=
									"jdbc:mysql://localhost:3306/mydb"
									p:username=
									"root"
									p:password=
									"masterkaoli"
									/>
									</beans>

The preceding XML is more succinct; however, typos are discovered at runtime rather than design time, unless you use an IDE such as IntelliJ IDEAor the Spring Tool Suite(STS) that support automatic property completion when you create bean definitions. Such IDE assistance is highly recommended.

You can also configure a java.util.Propertiesinstance as:

									<bean
									id=
									"mappings"
									class=
									"org.springframework.beans.factory.config.PropertyPlaceholderConfigurer"
									>
									<!-- typed as a java.util.Properties -->
									<property
									name=
									"properties"
									>
									<value>jdbc.driver.className=com.mysql.jdbc.Driver jdbc.url=jdbc:mysql://localhost:3306/mydb
									</value>
									</property>
									</bean>

The Spring container converts the text inside the <value/>element into a java.util.Propertiesinstance by using the JavaBeans PropertyEditormechanism. This is a nice shortcut, and is one of a few places where the Spring team do favor the use of the nested <value/>element over the valueattribute style.

The idref element

The idrefelement is simply an error-proof way to pass the id(string value - not a reference) of another bean in the container to a <constructor-arg/>or <property/>element.

										<bean
										id=
										"theTargetBean"
										class=
										"..."
										/>
										<bean
										id=
										"theClientBean"
										class=
										"..."
										>
										<property
										name=
										"targetName"
										>
										<idref
										bean=
										"theTargetBean"
										/>
										</property>
										</bean>

The above bean definition snippet is exactlyequivalent (at runtime) to the following snippet:

										<bean
										id=
										"theTargetBean"
										class=
										"..."
										/>
										<bean
										id=
										"client"
										class=
										"..."
										>
										<property
										name=
										"targetName"
										value=
										"theTargetBean"
										/>
										</bean>

The first form is preferable to the second, because using the idreftag allows the container to validate at deployment timethat the referenced, named bean actually exists. In the second variation, no validation is performed on the value that is passed to the targetNameproperty of the clientbean. Typos are only discovered (with most likely fatal results) when the clientbean is actually instantiated. If the clientbean is a prototypebean, this typo and the resulting exception may only be discovered long after the container is deployed.

[Note] Note

The localattribute on the idrefelement is no longer supported in the 4.0 beans xsd since it does not provide value over a regular beanreference anymore. Simply change your existing idref localreferences to idref beanwhen upgrading to the 4.0 schema.

A common place (at least in versions earlier than Spring 2.0) where the <idref/>element brings value is in the configuration of AOP interceptorsin a ProxyFactoryBeanbean definition. Using <idref/>elements when you specify the interceptor names prevents you from misspelling an interceptor id.

References to other beans (collaborators)

The refelement is the final element inside a <constructor-arg/>or <property/>definition element. Here you set the value of the specified property of a bean to be a reference to another bean (a collaborator) managed by the container. The referenced bean is a dependency of the bean whose property will be set, and it is initialized on demand as needed before the property is set. (If the collaborator is a singleton bean, it may be initialized already by the container.) All references are ultimately a reference to another object. Scoping and validation depend on whether you specify the id/name of the other object through the bean, local,or parentattributes.

Specifying the target bean through the beanattribute of the <ref/>tag is the most general form, and allows creation of a reference to any bean in the same container or parent container, regardless of whether it is in the same XML file. The value of the beanattribute may be the same as the idattribute of the target bean, or as one of the values in the nameattribute of the target bean.

									<ref
									bean=
									"someBean"
									/>

Specifying the target bean through the parentattribute creates a reference to a bean that is in a parent container of the current container. The value of the parentattribute may be the same as either the idattribute of the target bean, or one of the values in the nameattribute of the target bean, and the target bean must be in a parent container of the current one. You use this bean reference variant mainly when you have a hierarchy of containers and you want to wrap an existing bean in a parent container with a proxy that will have the same name as the parent bean.

									<!-- in the parent context -->
									<bean
									id=
									"accountService"
									class=
									"com.foo.SimpleAccountService"
									>
									<!-- insert dependencies as required as here -->
									</bean>
									<!-- in the child (descendant) context -->
									<bean
									id=
									"accountService"
									<!--
									bean
									name
									is
									the
									same
									as
									the
									parent
									bean
									-->
									class=
									"org.springframework.aop.framework.ProxyFactoryBean"
									>
									<property
									name=
									"target"
									>
									<ref
									parent=
									"accountService"
									/>
									<!-- notice how we refer to the parent bean -->
									</property>
									<!-- insert other configuration and dependencies as required here -->
									</bean>
[Note] Note

The localattribute on the refelement is no longer supported in the 4.0 beans xsd since it does not provide value over a regular beanreference anymore. Simply change your existing ref localreferences to ref beanwhen upgrading to the 4.0 schema.

Inner beans

A <bean/>element inside the <property/>or <constructor-arg/>elements defines a so-called inner bean.

									<bean
									id=
									"outer"
									class=
									"..."
									>
									<!-- instead of using a reference to a target bean, simply define the target bean inline -->
									<property
									name=
									"target"
									>
									<bean
									class=
									"com.example.Person"
									>
									<!-- this is the inner bean -->
									<property
									name=
									"name"
									value=
									"Fiona Apple"
									/>
									<property
									name=
									"age"
									value=
									"25"
									/>
									</bean>
									</property>
									</bean>

An inner bean definition does not require a defined id or name; if specified, the container does not use such a value as an identifier. The container also ignores the scopeflag on creation: Inner beans are alwaysanonymous and they are alwayscreated with the outer bean. It is notpossible to inject inner beans into collaborating beans other than into the enclosing bean or to access them independently.

As a corner case, it is possible to receive destruction callbacks from a custom scope, e.g. for a request-scoped inner bean contained within a singleton bean: The creation of the inner bean instance will be tied to its containing bean, but destruction callbacks allow it to participate in the request scope’s lifecycle. This is not a common scenario; inner beans typically simply share their containing bean’s scope.

Collections

In the <list/>, <set/>, <map/>, and <props/>elements, you set the properties and arguments of the Java Collectiontypes List, Set, Map, and Properties, respectively.

									<bean
									id=
									"moreComplexObject"
									class=
									"example.ComplexObject"
									>
									<!-- results in a setAdminEmails(java.util.Properties) call -->
									<property
									name=
									"adminEmails"
									>
									<props>
									<prop
									key=
									"administrator"
									>administrator@example.org
									</prop>
									<prop
									key=
									"support"
									>support@example.org
									</prop>
									<prop
									key=
									"development"
									>development@example.org
									</prop>
									</props>
									</property>
									<!-- results in a setSomeList(java.util.List) call -->
									<property
									name=
									"someList"
									>
									<list>
									<value>a list element followed by a reference
									</value>
									<ref
									bean=
									"myDataSource"
									/>
									</list>
									</property>
									<!-- results in a setSomeMap(java.util.Map) call -->
									<property
									name=
									"someMap"
									>
									<map>
									<entry
									key=
									"an entry"
									value=
									"just some string"
									/>
									<entry
									key=
									"a ref"
									value-ref=
									"myDataSource"
									/>
									</map>
									</property>
									<!-- results in a setSomeSet(java.util.Set) call -->
									<property
									name=
									"someSet"
									>
									<set>
									<value>just some string
									</value>
									<ref
									bean=
									"myDataSource"
									/>
									</set>
									</property>
									</bean>

The value of a map key or value, or a set value, can also again be any of the following elements: 

bean | ref | idref | list | set | map | props | value | null
Collection merging

The Spring container also supports the mergingof collections. An application developer can define a parent-style <list/>, <map/>, <set/>or <props/>element, and have child-style <list/>, <map/>, <set/>or <props/>elements inherit and override values from the parent collection. That is, the child collection’s values are the result of merging the elements of the parent and child collections, with the child’s collection elements overriding values specified in the parent collection.

This section on merging discusses the parent-child bean mechanism. Readers unfamiliar with parent and child bean definitions may wish to read the relevant sectionbefore continuing.

The following example demonstrates collection merging:

										<beans>
										<bean
										id=
										"parent"
										abstract=
										"true"
										class=
										"example.ComplexObject"
										>
										<property
										name=
										"adminEmails"
										>
										<props>
										<prop
										key=
										"administrator"
										>administrator@example.com
										</prop>
										<prop
										key=
										"support"
										>support@example.com
										</prop>
										</props>
										</property>
										</bean>
										<bean
										id=
										"child"
										parent=
										"parent"
										>
										<property
										name=
										"adminEmails"
										>
										<!-- the merge is specified on the child collection definition -->
										<props
										merge=
										"true"
										>
										<prop
										key=
										"sales"
										>sales@example.com
										</prop>
										<prop
										key=
										"support"
										>support@example.co.uk
										</prop>
										</props>
										</property>
										</bean>
										<beans>

Notice the use of the merge=trueattribute on the <props/>element of the adminEmailsproperty of the childbean definition. When the childbean is resolved and instantiated by the container, the resulting instance has an adminEmails Propertiescollection that contains the result of the merging of the child’s adminEmailscollection with the parent’s adminEmailscollection.

administrator=administrator@example.com sales=sales@example.com support=support@example.co.uk

The child Propertiescollection’s value set inherits all property elements from the parent <props/>, and the child’s value for the supportvalue overrides the value in the parent collection.

This merging behavior applies similarly to the <list/>, <map/>, and <set/>collection types. In the specific case of the <list/>element, the semantics associated with the Listcollection type, that is, the notion of an orderedcollection of values, is maintained; the parent’s values precede all of the child list’s values. In the case of the Map, Set, and Propertiescollection types, no ordering exists. Hence no ordering semantics are in effect for the collection types that underlie the associated Map, Set, and Propertiesimplementation types that the container uses internally.

Limitations of collection merging

You cannot merge different collection types (such as a Mapand a List), and if you do attempt to do so an appropriate Exceptionis thrown. The mergeattribute must be specified on the lower, inherited, child definition; specifying the mergeattribute on a parent collection definition is redundant and will not result in the desired merging.

Strongly-typed collection

With the introduction of generic types in Java 5, you can use strongly typed collections. That is, it is possible to declare a Collectiontype such that it can only contain Stringelements (for example). If you are using Spring to dependency-inject a strongly-typed Collectioninto a bean, you can take advantage of Spring’s type-conversion support such that the elements of your strongly-typed Collectioninstances are converted to the appropriate type prior to being added to the Collection.

										public
										classFoo {
										privateMap<String, Float> accounts;
										public
										voidsetAccounts(Map<String, Float> accounts) {
										this.accounts = accounts; } }
										<beans>
										<bean
										id=
										"foo"
										class=
										"x.y.Foo"
										>
										<property
										name=
										"accounts"
										>
										<map>
										<entry
										key=
										"one"
										value=
										"9.99"
										/>
										<entry
										key=
										"two"
										value=
										"2.75"
										/>
										<entry
										key=
										"six"
										value=
										"3.99"
										/>
										</map>
										</property>
										</bean>
										</beans>

When the accountsproperty of the foobean is prepared for injection, the generics information about the element type of the strongly-typed Map<String, Float>is available by reflection. Thus Spring’s type conversion infrastructure recognizes the various value elements as being of type Float, and the string values 9.99, 2.75, and 3.99are converted into an actual Floattype.

Null and empty string values

Spring treats empty arguments for properties and the like as empty Strings. The following XML-based configuration metadata snippet sets the email property to the empty Stringvalue ("").

									<bean
									class=
									"ExampleBean"
									>
									<property
									name=
									"email"
									value=
									""
									/>
									</bean>

The preceding example is equivalent to the following Java code:

exampleBean.setEmail(
									"")

The <null/>element handles nullvalues. For example:

									<bean
									class=
									"ExampleBean"
									>
									<property
									name=
									"email"
									>
									<null/>
									</property>
									</bean>

The above configuration is equivalent to the following Java code:

exampleBean.setEmail(null)

XML shortcut with the p-namespace

The p-namespace enables you to use the beanelement’s attributes, instead of nested <property/>elements, to describe your property values and/or collaborating beans.

Spring supports extensible configuration formats with namespaces, which are based on an XML Schema definition. The beansconfiguration format discussed in this chapter is defined in an XML Schema document. However, the p-namespace is not defined in an XSD file and exists only in the core of Spring.

The following example shows two XML snippets that resolve to the same result: The first uses standard XML format and the second uses the p-namespace.

									<beans
									xmlns=
									"http://www.springframework.org/schema/beans"
									xmlns:xsi=
									"http://www.w3.org/2001/XMLSchema-instance"
									xmlns:p=
									"http://www.springframework.org/schema/p"
									xsi:schemaLocation=
									"http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd"
									>
									<bean
									name=
									"classic"
									class=
									"com.example.ExampleBean"
									>
									<property
									name=
									"email"
									value=
									"foo@bar.com"
									/>
									</bean>
									<bean
									name=
									"p-namespace"
									class=
									"com.example.ExampleBean"
									p:email=
									"foo@bar.com"
									/>
									</beans>

The example shows an attribute in the p-namespace called email in the bean definition. This tells Spring to include a property declaration. As previously mentioned, the p-namespace does not have a schema definition, so you can set the name of the attribute to the property name.

This next example includes two more bean definitions that both have a reference to another bean:

									<beans
									xmlns=
									"http://www.springframework.org/schema/beans"
									xmlns:xsi=
									"http://www.w3.org/2001/XMLSchema-instance"
									xmlns:p=
									"http://www.springframework.org/schema/p"
									xsi:schemaLocation=
									"http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd"
									>
									<bean
									name=
									"john-classic"
									class=
									"com.example.Person"
									>
									<property
									name=
									"name"
									value=
									"John Doe"
									/>
									<property
									name=
									"spouse"
									ref=
									"jane"
									/>
									</bean>
									<bean
									name=
									"john-modern"
									class=
									"com.example.Person"
									p:name=
									"John Doe"
									p:spouse-ref=
									"jane"
									/>
									<bean
									name=
									"jane"
									class=
									"com.example.Person"
									>
									<property
									name=
									"name"
									value=
									"Jane Doe"
									/>
									</bean>
									</beans>

As you can see, this example includes not only a property value using the p-namespace, but also uses a special format to declare property references. Whereas the first bean definition uses <property name="spouse" ref="jane"/>to create a reference from bean johnto bean jane, the second bean definition uses p:spouse-ref="jane"as an attribute to do the exact same thing. In this case spouseis the property name, whereas the -refpart indicates that this is not a straight value but rather a reference to another bean.

[Note] Note

The p-namespace is not as flexible as the standard XML format. For example, the format for declaring property references clashes with properties that end in Ref, whereas the standard XML format does not. We recommend that you choose your approach carefully and communicate this to your team members, to avoid producing XML documents that use all three approaches at the same time.

XML shortcut with the c-namespace

Similar to the the section called “XML shortcut with the p-namespace”, the c-namespace, newly introduced in Spring 3.1, allows usage of inlined attributes for configuring the constructor arguments rather then nested constructor-argelements.

Let’s review the examples from the section called “Constructor-based dependency injection”with the c:namespace:

									<beans
									xmlns=
									"http://www.springframework.org/schema/beans"
									xmlns:xsi=
									"http://www.w3.org/2001/XMLSchema-instance"
									xmlns:c=
									"http://www.springframework.org/schema/c"
									xsi:schemaLocation=
									"http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd"
									>
									<bean
									id=
									"bar"
									class=
									"x.y.Bar"
									/>
									<bean
									id=
									"baz"
									class=
									"x.y.Baz"
									/>
									<!-- traditional declaration -->
									<bean
									id=
									"foo"
									class=
									"x.y.Foo"
									>
									<constructor-arg
									ref=
									"bar"
									/>
									<constructor-arg
									ref=
									"baz"
									/>
									<constructor-arg
									value=
									"foo@bar.com"
									/>
									</bean>
									<!-- c-namespace declaration -->
									<bean
									id=
									"foo"
									class=
									"x.y.Foo"
									c:bar-ref=
									"bar"
									c:baz-ref=
									"baz"
									c:email=
									"foo@bar.com"
									/>
									</beans>

The c:namespace uses the same conventions as the p:one (trailing -reffor bean references) for setting the constructor arguments by their names. And just as well, it needs to be declared even though it is not defined in an XSD schema (but it exists inside the Spring core).

For the rare cases where the constructor argument names are not available (usually if the bytecode was compiled without debugging information), one can use fallback to the argument indexes:

									<!-- c-namespace index declaration -->
									<bean
									id=
									"foo"
									class=
									"x.y.Foo"
									c:_0-ref=
									"bar"
									c:_1-ref=
									"baz"
									/>
[Note] Note

Due to the XML grammar, the index notation requires the presence of the leading _as XML attribute names cannot start with a number (even though some IDE allow it).

In practice, the constructor resolution mechanismis quite efficient in matching arguments so unless one really needs to, we recommend using the name notation through-out your configuration.

Compound property names

You can use compound or nested property names when you set bean properties, as long as all components of the path except the final property name are not null. Consider the following bean definition.

									<bean
									id=
									"foo"
									class=
									"foo.Bar"
									>
									<property
									name=
									"fred.bob.sammy"
									value=
									"123"
									/>
									</bean>

The foobean has a fredproperty, which has a bobproperty, which has a sammyproperty, and that final sammyproperty is being set to the value 123. In order for this to work, the fredproperty of foo, and the bobproperty of fredmust not be nullafter the bean is constructed, or a NullPointerExceptionis thrown.

7.4.3 Using depends-on

If a bean is a dependency of another that usually means that one bean is set as a property of another. Typically you accomplish this with the <ref/>elementin XML-based configuration metadata. However, sometimes dependencies between beans are less direct; for example, a static initializer in a class needs to be triggered, such as database driver registration. The depends-onattribute can explicitly force one or more beans to be initialized before the bean using this element is initialized. The following example uses the depends-onattribute to express a dependency on a single bean:

								<bean
								id=
								"beanOne"
								class=
								"ExampleBean"
								depends-on=
								"manager"
								/>
								<bean
								id=
								"manager"
								class=
								"ManagerBean"
								/>

To express a dependency on multiple beans, supply a list of bean names as the value of the depends-onattribute, with commas, whitespace and semicolons, used as valid delimiters:

								<bean
								id=
								"beanOne"
								class=
								"ExampleBean"
								depends-on=
								"manager,accountDao"
								>
								<property
								name=
								"manager"
								ref=
								"manager"
								/>
								</bean>
								<bean
								id=
								"manager"
								class=
								"ManagerBean"
								/>
								<bean
								id=
								"accountDao"
								class=
								"x.y.jdbc.JdbcAccountDao"
								/>
[Note] Note

The depends-onattribute in the bean definition can specify both an initialization time dependency and, in the case of singletonbeans only, a corresponding destroy time dependency. Dependent beans that define a depends-onrelationship with a given bean are destroyed first, prior to the given bean itself being destroyed. Thus depends-oncan also control shutdown order.

7.4.4 Lazy-initialized beans

By default, ApplicationContextimplementations eagerly create and configure all singletonbeans as part of the initialization process. Generally, this pre-instantiation is desirable, because errors in the configuration or surrounding environment are discovered immediately, as opposed to hours or even days later. When this behavior is notdesirable, you can prevent pre-instantiation of a singleton bean by marking the bean definition as lazy-initialized. A lazy-initialized bean tells the IoC container to create a bean instance when it is first requested, rather than at startup.

In XML, this behavior is controlled by the lazy-initattribute on the <bean/>element; for example:

								<bean
								id=
								"lazy"
								class=
								"com.foo.ExpensiveToCreateBean"
								lazy-init=
								"true"
								/>
								<bean
								name=
								"not.lazy"
								class=
								"com.foo.AnotherBean"
								/>

When the preceding configuration is consumed by an ApplicationContext, the bean named lazyis not eagerly pre-instantiated when the ApplicationContextis starting up, whereas the not.lazybean is eagerly pre-instantiated.

However, when a lazy-initialized bean is a dependency of a singleton bean that is notlazy-initialized, the ApplicationContextcreates the lazy-initialized bean at startup, because it must satisfy the singleton’s dependencies. The lazy-initialized bean is injected into a singleton bean elsewhere that is not lazy-initialized.

You can also control lazy-initialization at the container level by using the default-lazy-initattribute on the <beans/>element; for example:

								<beans
								default-lazy-init=
								"true"
								>
								<!-- no beans will be pre-instantiated... -->
								</beans>

7.4.5 Autowiring collaborators

The Spring container can autowirerelationships between collaborating beans. You can allow Spring to resolve collaborators (other beans) automatically for your bean by inspecting the contents of the ApplicationContext. Autowiring has the following advantages:

  • Autowiring can significantly reduce the need to specify properties or constructor arguments. (Other mechanisms such as a bean template discussed elsewhere in this chapterare also valuable in this regard.)
  • Autowiring can update a configuration as your objects evolve. For example, if you need to add a dependency to a class, that dependency can be satisfied automatically without you needing to modify the configuration. Thus autowiring can be especially useful during development, without negating the option of switching to explicit wiring when the code base becomes more stable.

When using XML-based configuration metadata [2], you specify autowire mode for a bean definition with the autowireattribute of the <bean/>element. The autowiring functionality has four modes. You specify autowiring perbean and thus can choose which ones to autowire.

Table 7.2. Autowiring modes

Mode Explanation

no

(Default) No autowiring. Bean references must be defined via a refelement. Changing the default setting is not recommended for larger deployments, because specifying collaborators explicitly gives greater control and clarity. To some extent, it documents the structure of a system.

byName

Autowiring by property name. Spring looks for a bean with the same name as the property that needs to be autowired. For example, if a bean definition is set to autowire by name, and it contains a masterproperty (that is, it has a setMaster(..)method), Spring looks for a bean definition named master, and uses it to set the property.

byType

Allows a property to be autowired if exactly one bean of the property type exists in the container. If more than one exists, a fatal exception is thrown, which indicates that you may not use byTypeautowiring for that bean. If there are no matching beans, nothing happens; the property is not set.

constructor

Analogous to byType, but applies to constructor arguments. If there is not exactly one bean of the constructor argument type in the container, a fatal error is raised.

With byTypeor constructorautowiring mode, you can wire arrays and typed-collections. In such cases allautowire candidates within the container that match the expected type are provided to satisfy the dependency. You can autowire strongly-typed Maps if the expected key type is String. An autowired Maps values will consist of all bean instances that match the expected type, and the Maps keys will contain the corresponding bean names.

You can combine autowire behavior with dependency checking, which is performed after autowiring completes.

Limitations and disadvantages of autowiring

Autowiring works best when it is used consistently across a project. If autowiring is not used in general, it might be confusing to developers to use it to wire only one or two bean definitions.

Consider the limitations and disadvantages of autowiring:

  • Explicit dependencies in propertyand constructor-argsettings always override autowiring. You cannot autowire so-called simpleproperties such as primitives, Strings, and Classes(and arrays of such simple properties). This limitation is by-design.
  • Autowiring is less exact than explicit wiring. Although, as noted in the above table, Spring is careful to avoid guessing in case of ambiguity that might have unexpected results, the relationships between your Spring-managed objects are no longer documented explicitly.
  • Wiring information may not be available to tools that may generate documentation from a Spring container.
  • Multiple bean definitions within the container may match the type specified by the setter method or constructor argument to be autowired. For arrays, collections, or Maps, this is not necessarily a problem. However for dependencies that expect a single value, this ambiguity is not arbitrarily resolved. If no unique bean definition is available, an exception is thrown.

In the latter scenario, you have several options:

  • Abandon autowiring in favor of explicit wiring.
  • Avoid autowiring for a bean definition by setting its autowire-candidateattributes to falseas described in the next section.
  • Designate a single bean definition as the primarycandidate by setting the primaryattribute of its <bean/>element to true.
  • Implement the more fine-grained control available with annotation-based configuration, as described in Section 7.9, “Annotation-based container configuration”.

Excluding a bean from autowiring

On a per-bean basis, you can exclude a bean from autowiring. In Spring’s XML format, set the autowire-candidateattribute of the <bean/>element to false; the container makes that specific bean definition unavailable to the autowiring infrastructure (including annotation style configurations such as @Autowired).

You can also limit autowire candidates based on pattern-matching against bean names. The top-level <beans/>element accepts one or more patterns within its default-autowire-candidatesattribute. For example, to limit autowire candidate status to any bean whose name ends with Repository,provide a value of *Repository. To provide multiple patterns, define them in a comma-separated list. An explicit value of trueor falsefor a bean definitions autowire-candidateattribute always takes precedence, and for such beans, the pattern matching rules do not apply.

These techniques are useful for beans that you never want to be injected into other beans by autowiring. It does not mean that an excluded bean cannot itself be configured using autowiring. Rather, the bean itself is not a candidate for autowiring other beans.

7.4.6 Method injection

In most application scenarios, most beans in the container are singletons. When a singleton bean needs to collaborate with another singleton bean, or a non-singleton bean needs to collaborate with another non-singleton bean, you typically handle the dependency by defining one bean as a property of the other. A problem arises when the bean lifecycles are different. Suppose singleton bean A needs to use non-singleton (prototype) bean B, perhaps on each method invocation on A. The container only creates the singleton bean A once, and thus only gets one opportunity to set the properties. The container cannot provide bean A with a new instance of bean B every time one is needed.

A solution is to forego some inversion of control. You can make bean A aware of the containerby implementing the ApplicationContextAwareinterface, and by making a getBean("B") call to the containerask for (a typically new) bean B instance every time bean A needs it. The following is an example of this approach:

								// a class that uses a stateful Command-style class to perform some processing
								packagefiona.apple;
								// Spring-API imports
								importorg.springframework.beans.BeansException;
								importorg.springframework.context.ApplicationContext;
								importorg.springframework.context.ApplicationContextAware;
								public
								classCommandManager
								implementsApplicationContextAware {
								privateApplicationContext applicationContext;
								publicObject process(Map commandState) {
								// grab a new instance of the appropriate CommandCommand command = createCommand();
								// set the state on the (hopefully brand new) Command instancecommand.setState(commandState);
								returncommand.execute(); }
								protectedCommand createCommand() {
								// notice the Spring API dependency!
								return
								this.applicationContext.getBean(
								"command", Command.
								class); }
								public
								voidsetApplicationContext( ApplicationContext applicationContext)
								throwsBeansException {
								this.applicationContext = applicationContext; } }

The preceding is not desirable, because the business code is aware of and coupled to the Spring Framework. Method Injection, a somewhat advanced feature of the Spring IoC container, allows this use case to be handled in a clean fashion.

You can read more about the motivation for Method Injection in this blog entry.

Lookup method injection

Lookup method injection is the ability of the container to override methods on container managed beans, to return the lookup result for another named bean in the container. The lookup typically involves a prototype bean as in the scenario described in the preceding section. The Spring Framework implements this method injection by using bytecode generation from the CGLIB library to generate dynamically a subclass that overrides the method.

[Note] Note
  • For this dynamic subclassing to work, the class that the Spring bean container will subclass cannot be final, and the method to be overridden cannot be finaleither.
  • Unit-testing a class that has an abstractmethod requires you to subclass the class yourself and to supply a stub implementation of the abstractmethod.
  • Concrete methods are also necessary for component scanning which requires concrete classes to pick up.
  • A further key limitation is that lookup methods won’t work with factory methods and in particular not with @Beanmethods in configuration classes, since the container is not in charge of creating the instance in that case and therefore cannot create a runtime-generated subclass on the fly.

Looking at the CommandManagerclass in the previous code snippet, you see that the Spring container will dynamically override the implementation of the createCommand()method. Your CommandManagerclass will not have any Spring dependencies, as can be seen in the reworked example:

									packagefiona.apple;
									// no more Spring imports!
									public
									abstract
									classCommandManager {
									publicObject process(Object commandState) {
									// grab a new instance of the appropriate Command interfaceCommand command = createCommand();
									// set the state on the (hopefully brand new) Command instancecommand.setState(commandState);
									returncommand.execute(); }
									// okay... but where is the implementation of this method?
									protected
									abstractCommand createCommand(); }

In the client class containing the method to be injected (the CommandManagerin this case), the method to be injected requires a signature of the following form:

									<public|protected>[abstract]
									<return-type>theMethodName(no-arguments);

If the method is abstract, the dynamically-generated subclass implements the method. Otherwise, the dynamically-generated subclass overrides the concrete method defined in the original class. For example:

									<!-- a stateful bean deployed as a prototype (non-singleton) -->
									<bean
									id=
									"myCommand"
									class=
									"fiona.apple.AsyncCommand"
									scope=
									"prototype"
									>
									<!-- inject dependencies here as required -->
									</bean>
									<!-- commandProcessor uses statefulCommandHelper -->
									<bean
									id=
									"commandManager"
									class=
									"fiona.apple.CommandManager"
									>
									<lookup-method
									name=
									"createCommand"
									bean=
									"myCommand"
									/>
									</bean>

The bean identified as commandManagercalls its own method createCommand()whenever it needs a new instance of the myCommandbean. You must be careful to deploy the myCommandbean as a prototype, if that is actually what is needed. If it is as a singleton, the same instance of the myCommandbean is returned each time.

Alternatively, within the annotation-based component model, you may declare a lookup method through the @Lookupannotation:

									public
									abstract
									classCommandManager {
									publicObject process(Object commandState) { Command command = createCommand(); command.setState(commandState);
									returncommand.execute(); }
									
										@Lookup("myCommand")
									protected
									abstractCommand createCommand(); }

Or, more idiomatically, you may rely on the target bean getting resolved against the declared return type of the lookup method:

									public
									abstract
									classCommandManager {
									publicObject process(Object commandState) { MyCommand command = createCommand(); command.setState(commandState);
									returncommand.execute(); }
									
										@Lookup
									protected
									abstractMyCommand createCommand(); }

Note that you will typically declare such annotated lookup methods with a concrete stub implementation, in order for them to be compatible with Spring’s component scanning rules where abstract classes get ignored by default. This limitation does not apply in case of explicitly registered or explicitly imported bean classes.

[Tip] Tip

Another way of accessing differently scoped target beans is an ObjectFactory/ Providerinjection point. Check out the section called “Scoped beans as dependencies”.

The interested reader may also find the ServiceLocatorFactoryBean(in the org.springframework.beans.factory.configpackage) to be of use.

Arbitrary method replacement

A less useful form of method injection than lookup method injection is the ability to replace arbitrary methods in a managed bean with another method implementation. Users may safely skip the rest of this section until the functionality is actually needed.

With XML-based configuration metadata, you can use the replaced-methodelement to replace an existing method implementation with another, for a deployed bean. Consider the following class, with a method computeValue, which we want to override:

									public
									classMyValueCalculator {
									publicString computeValue(String input) {
									// some real code...}
									// some other methods...}

A class implementing the org.springframework.beans.factory.support.MethodReplacerinterface provides the new method definition.

									/** * meant to be used to override the existing computeValue(String) * implementation in MyValueCalculator */
									public
									classReplacementComputeValue
									implementsMethodReplacer {
									publicObject reimplement(Object o, Method m, Object[] args)
									throwsThrowable {
									// get the input value, work with it, and return a computed resultString input = (String) args[
									0]; ...
									return...; } }

The bean definition to deploy the original class and specify the method override would look like this:

									<bean
									id=
									"myValueCalculator"
									class=
									"x.y.z.MyValueCalculator"
									>
									<!-- arbitrary method replacement -->
									<replaced-method
									name=
									"computeValue"
									replacer=
									"replacementComputeValue"
									>
									<arg-type>String
									</arg-type>
									</replaced-method>
									</bean>
									<bean
									id=
									"replacementComputeValue"
									class=
									"a.b.c.ReplacementComputeValue"
									/>

You can use one or more contained <arg-type/>elements within the <replaced-method/>element to indicate the method signature of the method being overridden. The signature for the arguments is necessary only if the method is overloaded and multiple variants exist within the class. For convenience, the type string for an argument may be a substring of the fully qualified type name. For example, the following all match java.lang.String:

java.lang.String String Str

Because the number of arguments is often enough to distinguish between each possible choice, this shortcut can save a lot of typing, by allowing you to type only the shortest string that will match an argument type.

7.5 Bean scopes

When you create a bean definition, you create a recipefor creating actual instances of the class defined by that bean definition. The idea that a bean definition is a recipe is important, because it means that, as with a class, you can create many object instances from a single recipe.

You can control not only the various dependencies and configuration values that are to be plugged into an object that is created from a particular bean definition, but also the scopeof the objects created from a particular bean definition. This approach is powerful and flexible in that you can choosethe scope of the objects you create through configuration instead of having to bake in the scope of an object at the Java class level. Beans can be defined to be deployed in one of a number of scopes: out of the box, the Spring Framework supports seven scopes, five of which are available only if you use a web-aware ApplicationContext.

The following scopes are supported out of the box. You can also create a custom scope.

Table 7.3. Bean scopes

Scope Description

singleton

(Default) Scopes a single bean definition to a single object instance per Spring IoC container.

prototype

Scopes a single bean definition to any number of object instances.

request

Scopes a single bean definition to the lifecycle of a single HTTP request; that is, each HTTP request has its own instance of a bean created off the back of a single bean definition. Only valid in the context of a web-aware Spring ApplicationContext.

session

Scopes a single bean definition to the lifecycle of an HTTP Session. Only valid in the context of a web-aware Spring ApplicationContext.

globalSession

Scopes a single bean definition to the lifecycle of a global HTTP Session. Typically only valid when used in a Portlet context. Only valid in the context of a web-aware Spring ApplicationContext.

application

Scopes a single bean definition to the lifecycle of a ServletContext. Only valid in the context of a web-aware Spring ApplicationContext.

websocket

Scopes a single bean definition to the lifecycle of a WebSocket. Only valid in the context of a web-aware Spring ApplicationContext.

[Note] Note

As of Spring 3.0, a thread scopeis available, but is not registered by default. For more information, see the documentation for SimpleThreadScope. For instructions on how to register this or any other custom scope, see the section called “Using a custom scope”.

7.5.1 The singleton scope

Only one sharedinstance of a singleton bean is managed, and all requests for beans with an id or ids matching that bean definition result in that one specific bean instance being returned by the Spring container.

To put it another way, when you define a bean definition and it is scoped as a singleton, the Spring IoC container creates exactly oneinstance of the object defined by that bean definition. This single instance is stored in a cache of such singleton beans, and all subsequent requests and referencesfor that named bean return the cached object.

singleton

Spring’s concept of a singleton bean differs from the Singleton pattern as defined in the Gang of Four (GoF) patterns book. The GoF Singleton hard-codes the scope of an object such that one and only oneinstance of a particular class is created per ClassLoader. The scope of the Spring singleton is best described as per container and per bean. This means that if you define one bean for a particular class in a single Spring container, then the Spring container creates one and only oneinstance of the class defined by that bean definition. The singleton scope is the default scope in Spring. To define a bean as a singleton in XML, you would write, for example:

								<bean
								id=
								"accountService"
								class=
								"com.foo.DefaultAccountService"
								/>
								<!-- the following is equivalent, though redundant (singleton scope is the default) -->
								<bean
								id=
								"accountService"
								class=
								"com.foo.DefaultAccountService"
								scope=
								"singleton"
								/>

7.5.2 The prototype scope

The non-singleton, prototype scope of bean deployment results in the creation of a new bean instanceevery time a request for that specific bean is made. That is, the bean is injected into another bean or you request it through a getBean()method call on the container. As a rule, use the prototype scope for all stateful beans and the singleton scope for stateless beans.

The following diagram illustrates the Spring prototype scope. A data access object (DAO) is not typically configured as a prototype, because a typical DAO does not hold any conversational state; it was just easier for this author to reuse the core of the singleton diagram.

prototype

The following example defines a bean as a prototype in XML:

								<bean
								id=
								"accountService"
								class=
								"com.foo.DefaultAccountService"
								scope=
								"prototype"
								/>

In contrast to the other scopes, Spring does not manage the complete lifecycle of a prototype bean: the container instantiates, configures, and otherwise assembles a prototype object, and hands it to the client, with no further record of that prototype instance. Thus, although initializationlifecycle callback methods are called on all objects regardless of scope, in the case of prototypes, configured destructionlifecycle callbacks are notcalled. The client code must clean up prototype-scoped objects and release expensive resources that the prototype bean(s) are holding. To get the Spring container to release resources held by prototype-scoped beans, try using a custom bean post-processor, which holds a reference to beans that need to be cleaned up.

In some respects, the Spring container’s role in regard to a prototype-scoped bean is a replacement for the Java newoperator. All lifecycle management past that point must be handled by the client. (For details on the lifecycle of a bean in the Spring container, see Section 7.6.1, “Lifecycle callbacks”.)

7.5.3 Singleton beans with prototype-bean dependencies

When you use singleton-scoped beans with dependencies on prototype beans, be aware that dependencies are resolved at instantiation time. Thus if you dependency-inject a prototype-scoped bean into a singleton-scoped bean, a new prototype bean is instantiated and then dependency-injected into the singleton bean. The prototype instance is the sole instance that is ever supplied to the singleton-scoped bean.

However, suppose you want the singleton-scoped bean to acquire a new instance of the prototype-scoped bean repeatedly at runtime. You cannot dependency-inject a prototype-scoped bean into your singleton bean, because that injection occurs only once, when the Spring container is instantiating the singleton bean and resolving and injecting its dependencies. If you need a new instance of a prototype bean at runtime more than once, see Section 7.4.6, “Method injection”

7.5.4 Request, session, global session, application, and WebSocket scopes

The request, session, globalSession, application, and websocketscopes are onlyavailable if you use a web-aware Spring ApplicationContextimplementation (such as XmlWebApplicationContext). If you use these scopes with regular Spring IoC containers such as the ClassPathXmlApplicationContext, an IllegalStateExceptionwill be thrown complaining about an unknown bean scope.

Initial web configuration

To support the scoping of beans at the request, session, globalSession, application, and websocketlevels (web-scoped beans), some minor initial configuration is required before you define your beans. (This initial setup is notrequired for the standard scopes, singletonand prototype.)

How you accomplish this initial setup depends on your particular Servlet environment.

If you access scoped beans within Spring Web MVC, in effect, within a request that is processed by the Spring DispatcherServletor DispatcherPortlet, then no special setup is necessary: DispatcherServletand DispatcherPortletalready expose all relevant state.

If you use a Servlet 2.5 web container, with requests processed outside of Spring’s DispatcherServlet(for example, when using JSF or Struts), you need to register the org.springframework.web.context.request.RequestContextListener ServletRequestListener. For Servlet 3.0+, this can be done programmatically via the WebApplicationInitializerinterface. Alternatively, or for older containers, add the following declaration to your web application’s web.xmlfile:

									<web-app>...
									<listener>
									<listener-class>org.springframework.web.context.request.RequestContextListener
									</listener-class>
									</listener>...
									</web-app>

Alternatively, if there are issues with your listener setup, consider using Spring’s RequestContextFilter. The filter mapping depends on the surrounding web application configuration, so you have to change it as appropriate.

									<web-app>...
									<filter>
									<filter-name>requestContextFilter
									</filter-name>
									<filter-class>org.springframework.web.filter.RequestContextFilter
									</filter-class>
									</filter>
									<filter-mapping>
									<filter-name>requestContextFilter
									</filter-name>
									<url-pattern>/*
									</url-pattern>
									</filter-mapping>...
									</web-app>

DispatcherServlet, RequestContextListener, and RequestContextFilterall do exactly the same thing, namely bind the HTTP request object to the Threadthat is servicing that request. This makes beans that are request- and session-scoped available further down the call chain.

Request scope

Consider the following XML configuration for a bean definition:

									<bean
									id=
									"loginAction"
									class=
									"com.foo.LoginAction"
									scope=
									"request"
									/>

The Spring container creates a new instance of the LoginActionbean by using the loginActionbean definition for each and every HTTP request. That is, the loginActionbean is scoped at the HTTP request level. You can change the internal state of the instance that is created as much as you want, because other instances created from the same loginActionbean definition will not see these changes in state; they are particular to an individual request. When the request completes processing, the bean that is scoped to the request is discarded.

When using annotation-driven components or Java Config, the @RequestScopeannotation can be used to assign a component to the requestscope.

									
										@RequestScope
									
										@Component
									public
									classLoginAction {
									// ...}

Session scope

Consider the following XML configuration for a bean definition:

									<bean
									id=
									"userPreferences"
									class=
									"com.foo.UserPreferences"
									scope=
									"session"
									/>

The Spring container creates a new instance of the UserPreferencesbean by using the userPreferencesbean definition for the lifetime of a single HTTP Session. In other words, the userPreferencesbean is effectively scoped at the HTTP Sessionlevel. As with request-scopedbeans, you can change the internal state of the instance that is created as much as you want, knowing that other HTTP Sessioninstances that are also using instances created from the same userPreferencesbean definition do not see these changes in state, because they are particular to an individual HTTP Session. When the HTTP Sessionis eventually discarded, the bean that is scoped to that particular HTTP Sessionis also discarded.

When using annotation-driven components or Java Config, the @SessionScopeannotation can be used to assign a component to the sessionscope.

									
										@SessionScope
									
										@Component
									public
									classUserPreferences {
									// ...}

Global session scope

Consider the following bean definition:

									<bean
									id=
									"userPreferences"
									class=
									"com.foo.UserPreferences"
									scope=
									"globalSession"
									/>

The globalSessionscope is similar to the standard HTTP Sessionscope ( described above), and applies only in the context of portlet-based web applications. The portlet specification defines the notion of a global Sessionthat is shared among all portlets that make up a single portlet web application. Beans defined at the globalSessionscope are scoped (or bound) to the lifetime of the global portlet Session.

If you write a standard Servlet-based web application and you define one or more beans as having globalSessionscope, the standard HTTP Sessionscope is used, and no error is raised.

Application scope

Consider the following XML configuration for a bean definition:

									<bean
									id=
									"appPreferences"
									class=
									"com.foo.AppPreferences"
									scope=
									"application"
									/>

The Spring container creates a new instance of the AppPreferencesbean by using the appPreferencesbean definition once for the entire web application. That is, the appPreferencesbean is scoped at the ServletContextlevel, stored as a regular ServletContextattribute. This is somewhat similar to a Spring singleton bean but differs in two important ways: It is a singleton per ServletContext, not per Spring 'ApplicationContext' (for which there may be several in any given web application), and it is actually exposed and therefore visible as a ServletContextattribute.

When using annotation-driven components or Java Config, the @ApplicationScopeannotation can be used to assign a component to the applicationscope.

									
										@ApplicationScope
									
										@Component
									public
									classAppPreferences {
									// ...}

Scoped beans as dependencies

The Spring IoC container manages not only the instantiation of your objects (beans), but also the wiring up of collaborators (or dependencies). If you want to inject (for example) an HTTP request scoped bean into another bean of a longer-lived scope, you may choose to inject an AOP proxy in place of the scoped bean. That is, you need to inject a proxy object that exposes the same public interface as the scoped object but that can also retrieve the real target object from the relevant scope (such as an HTTP request) and delegate method calls onto the real object.

[Note] Note

You may also use <aop:scoped-proxy/>between beans that are scoped as singleton, with the reference then going through an intermediate proxy that is serializable and therefore able to re-obtain the target singleton bean on deserialization.

When declaring <aop:scoped-proxy/>against a bean of scope prototype, every method call on the shared proxy will lead to the creation of a new target instance which the call is then being forwarded to.

Also, scoped proxies are not the only way to access beans from shorter scopes in a lifecycle-safe fashion. You may also simply declare your injection point (i.e. the constructor/setter argument or autowired field) as ObjectFactory<MyTargetBean>, allowing for a getObject()call to retrieve the current instance on demand every time it is needed - without holding on to the instance or storing it separately.

The JSR-330 variant of this is called Provider, used with a Provider<MyTargetBean>declaration and a corresponding get()call for every retrieval attempt. See herefor more details on JSR-330 overall.

The configuration in the following example is only one line, but it is important to understand the "why" as well as the "how" behind it.

									<?xml version="1.0" encoding="UTF-8"?>
									<beans
									xmlns=
									"http://www.springframework.org/schema/beans"
									xmlns:xsi=
									"http://www.w3.org/2001/XMLSchema-instance"
									xmlns:aop=
									"http://www.springframework.org/schema/aop"
									xsi:schemaLocation=
									"http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd"
									>
									<!-- an HTTP Session-scoped bean exposed as a proxy -->
									<bean
									id=
									"userPreferences"
									class=
									"com.foo.UserPreferences"
									scope=
									"session"
									>
									<!-- instructs the container to proxy the surrounding bean -->
									<aop:scoped-proxy/>
									</bean>
									<!-- a singleton-scoped bean injected with a proxy to the above bean -->
									<bean
									id=
									"userService"
									class=
									"com.foo.SimpleUserService"
									>
									<!-- a reference to the proxied userPreferences bean -->
									<property
									name=
									"userPreferences"
									ref=
									"userPreferences"
									/>
									</bean>
									</beans>

To create such a proxy, you insert a child <aop:scoped-proxy/>element into a scoped bean definition (see the section called “Choosing the type of proxy to create”and Chapter 41, XML Schema-based configuration ). Why do definitions of beans scoped at the request, session, globalSessionand custom-scope levels require the <aop:scoped-proxy/>element? Let’s examine the following singleton bean definition and contrast it with what you need to define for the aforementioned scopes (note that the following userPreferencesbean definition as it stands is incomplete).

									<bean
									id=
									"userPreferences"
									class=
									"com.foo.UserPreferences"
									scope=
									"session"
									/>
									<bean
									id=
									"userManager"
									class=
									"com.foo.UserManager"
									>
									<property
									name=
									"userPreferences"
									ref=
									"userPreferences"
									/>
									</bean>

In the preceding example, the singleton bean userManageris injected with a reference to the HTTP Session-scoped bean userPreferences. The salient point here is that the userManagerbean is a singleton: it will be instantiated exactly onceper container, and its dependencies (in this case only one, the userPreferencesbean) are also injected only once. This means that the userManagerbean will only operate on the exact same userPreferencesobject, that is, the one that it was originally injected with.

This is notthe behavior you want when injecting a shorter-lived scoped bean into a longer-lived scoped bean, for example injecting an HTTP Session-scoped collaborating bean as a dependency into singleton bean. Rather, you need a single userManagerobject, and for the lifetime of an HTTP Session, you need a userPreferencesobject that is specific to said HTTP Session. Thus the container creates an object that exposes the exact same public interface as the UserPreferencesclass (ideally an object that is a UserPreferencesinstance) which can fetch the real UserPreferencesobject from the scoping mechanism (HTTP request, Session, etc.). The container injects this proxy object into the userManagerbean, which is unaware that this UserPreferencesreference is a proxy. In this example, when a UserManagerinstance invokes a method on the dependency-injected UserPreferencesobject, it actually is invoking a method on the proxy. The proxy then fetches the real UserPreferencesobject from (in this case) the HTTP Session, and delegates the method invocation onto the retrieved real UserPreferencesobject.

Thus you need the following, correct and complete, configuration when injecting request-, session-, and globalSession-scopedbeans into collaborating objects:

									<bean
									id=
									"userPreferences"
									class=
									"com.foo.UserPreferences"
									scope=
									"session"
									>
									<aop:scoped-proxy/>
									</bean>
									<bean
									id=
									"userManager"
									class=
									"com.foo.UserManager"
									>
									<property
									name=
									"userPreferences"
									ref=
									"userPreferences"
									/>
									</bean>
Choosing the type of proxy to create

By default, when the Spring container creates a proxy for a bean that is marked up with the <aop:scoped-proxy/>element, a CGLIB-based class proxy is created.

[Note] Note

CGLIB proxies only intercept public method calls! Do not call non-public methods on such a proxy; they will not be delegated to the actual scoped target object.

Alternatively, you can configure the Spring container to create standard JDK interface-based proxies for such scoped beans, by specifying falsefor the value of the proxy-target-classattribute of the <aop:scoped-proxy/>element. Using JDK interface-based proxies means that you do not need additional libraries in your application classpath to effect such proxying. However, it also means that the class of the scoped bean must implement at least one interface, and that allcollaborators into which the scoped bean is injected must reference the bean through one of its interfaces.

										<!-- DefaultUserPreferences implements the UserPreferences interface -->
										<bean
										id=
										"userPreferences"
										class=
										"com.foo.DefaultUserPreferences"
										scope=
										"session"
										>
										<aop:scoped-proxy
										proxy-target-class=
										"false"
										/>
										</bean>
										<bean
										id=
										"userManager"
										class=
										"com.foo.UserManager"
										>
										<property
										name=
										"userPreferences"
										ref=
										"userPreferences"
										/>
										</bean>

For more detailed information about choosing class-based or interface-based proxying, see Section 11.6, “Proxying mechanisms”.

7.5.5 Custom scopes

The bean scoping mechanism is extensible; You can define your own scopes, or even redefine existing scopes, although the latter is considered bad practice and you cannotoverride the built-in singletonand prototypescopes.

Creating a custom scope

To integrate your custom scope(s) into the Spring container, you need to implement the org.springframework.beans.factory.config.Scopeinterface, which is described in this section. For an idea of how to implement your own scopes, see the Scopeimplementations that are supplied with the Spring Framework itself and the Scopejavadocs, which explains the methods you need to implement in more detail.

The Scopeinterface has four methods to get objects from the scope, remove them from the scope, and allow them to be destroyed.

The following method returns the object from the underlying scope. The session scope implementation, for example, returns the session-scoped bean (and if it does not exist, the method returns a new instance of the bean, after having bound it to the session for future reference).

Object get(String name, ObjectFactory objectFactory)

The following method removes the object from the underlying scope. The session scope implementation for example, removes the session-scoped bean from the underlying session. The object should be returned, but you can return null if the object with the specified name is not found.

Object remove(String name)

The following method registers the callbacks the scope should execute when it is destroyed or when the specified object in the scope is destroyed. Refer to the javadocs or a Spring scope implementation for more information on destruction callbacks.

									voidregisterDestructionCallback(String name, Runnable destructionCallback)

The following method obtains the conversation identifier for the underlying scope. This identifier is different for each scope. For a session scoped implementation, this identifier can be the session identifier.

String getConversationId()

Using a custom scope

After you write and test one or more custom Scopeimplementations, you need to make the Spring container aware of your new scope(s). The following method is the central method to register a new Scopewith the Spring container:

									voidregisterScope(String scopeName, Scope scope);

This method is declared on the ConfigurableBeanFactoryinterface, which is available on most of the concrete ApplicationContextimplementations that ship with Spring via the BeanFactory property.

The first argument to the registerScope(..)method is the unique name associated with a scope; examples of such names in the Spring container itself are singletonand prototype. The second argument to the registerScope(..)method is an actual instance of the custom Scopeimplementation that you wish to register and use.

Suppose that you write your custom Scopeimplementation, and then register it as below.

[Note] Note

The example below uses SimpleThreadScopewhich is included with Spring, but not registered by default. The instructions would be the same for your own custom Scopeimplementations.

 
Scope threadScope =
									newSimpleThreadScope(); beanFactory.registerScope(
									"thread", threadScope);

You then create bean definitions that adhere to the scoping rules of your custom Scope:

									<bean
									id=
									"..."
									class=
									"..."
									scope=
									"thread"
									>

With a custom Scopeimplementation, you are not limited to programmatic registration of the scope. You can also do the Scoperegistration declaratively, using the CustomScopeConfigurerclass:

									<?xml version="1.0" encoding="UTF-8"?>
									<beans
									xmlns=
									"http://www.springframework.org/schema/beans"
									xmlns:xsi=
									"http://www.w3.org/2001/XMLSchema-instance"
									xmlns:aop=
									"http://www.springframework.org/schema/aop"
									xsi:schemaLocation=
									"http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd"
									>
									<bean
									class=
									"org.springframework.beans.factory.config.CustomScopeConfigurer"
									>
									<property
									name=
									"scopes"
									>
									<map>
									<entry
									key=
									"thread"
									>
									<bean
									class=
									"org.springframework.context.support.SimpleThreadScope"
									/>
									</entry>
									</map>
									</property>
									</bean>
									<bean
									id=
									"bar"
									class=
									"x.y.Bar"
									scope=
									"thread"
									>
									<property
									name=
									"name"
									value=
									"Rick"
									/>
									<aop:scoped-proxy/>
									</bean>
									<bean
									id=
									"foo"
									class=
									"x.y.Foo"
									>
									<property
									name=
									"bar"
									ref=
									"bar"
									/>
									</bean>
									</beans>
[Note] Note

When you place <aop:scoped-proxy/>in a FactoryBeanimplementation, it is the factory bean itself that is scoped, not the object returned from getObject().

7.6 Customizing the nature of a bean

7.6.1 Lifecycle callbacks

To interact with the container’s management of the bean lifecycle, you can implement the Spring InitializingBeanand DisposableBeaninterfaces. The container calls afterPropertiesSet()for the former and destroy()for the latter to allow the bean to perform certain actions upon initialization and destruction of your beans.

[Tip] Tip

The JSR-250 @PostConstructand @PreDestroyannotations are generally considered best practice for receiving lifecycle callbacks in a modern Spring application. Using these annotations means that your beans are not coupled to Spring specific interfaces. For details see Section 7.9.8, “@PostConstruct and @PreDestroy”.

If you don’t want to use the JSR-250 annotations but you are still looking to remove coupling consider the use of init-method and destroy-method object definition metadata.

Internally, the Spring Framework uses BeanPostProcessorimplementations to process any callback interfaces it can find and call the appropriate methods. If you need custom features or other lifecycle behavior Spring does not offer out-of-the-box, you can implement a BeanPostProcessoryourself. For more information, see Section 7.8, “Container Extension Points”.

In addition to the initialization and destruction callbacks, Spring-managed objects may also implement the Lifecycleinterface so that those objects can participate in the startup and shutdown process as driven by the container’s own lifecycle.

The lifecycle callback interfaces are described in this section.

Initialization callbacks

The org.springframework.beans.factory.InitializingBeaninterface allows a bean to perform initialization work after all necessary properties on the bean have been set by the container. The InitializingBeaninterface specifies a single method:

									voidafterPropertiesSet()
									throwsException;

It is recommended that you do not use the InitializingBeaninterface because it unnecessarily couples the code to Spring. Alternatively, use the @PostConstructannotation or specify a POJO initialization method. In the case of XML-based configuration metadata, you use the init-methodattribute to specify the name of the method that has a void no-argument signature. With Java config, you use the initMethodattribute of @Bean, see the section called “Receiving lifecycle callbacks”. For example, the following:

									<bean
									id=
									"exampleInitBean"
									class=
									"examples.ExampleBean"
									init-method=
									"init"
									/>
									public
									classExampleBean {
									public
									voidinit() {
									// do some initialization work} }

…​is exactly the same as…​

									<bean
									id=
									"exampleInitBean"
									class=
									"examples.AnotherExampleBean"
									/>
									public
									classAnotherExampleBean
									implementsInitializingBean {
									public
									voidafterPropertiesSet() {
									// do some initialization work} }

but does not couple the code to Spring.

Destruction callbacks

Implementing the org.springframework.beans.factory.DisposableBeaninterface allows a bean to get a callback when the container containing it is destroyed. The DisposableBeaninterface specifies a single method:

									voiddestroy()
									throwsException;

It is recommended that you do not use the DisposableBeancallback interface because it unnecessarily couples the code to Spring. Alternatively, use the @PreDestroyannotation or specify a generic method that is supported by bean definitions. With XML-based configuration metadata, you use the destroy-methodattribute on the <bean/>. With Java config, you use the destroyMethodattribute of @Bean, see the section called “Receiving lifecycle callbacks”. For example, the following definition:

									<bean
									id=
									"exampleInitBean"
									class=
									"examples.ExampleBean"
									destroy-method=
									"cleanup"
									/>
									public
									classExampleBean {
									public
									voidcleanup() {
									// do some destruction work (like releasing pooled connections)} }

is exactly the same as:

									<bean
									id=
									"exampleInitBean"
									class=
									"examples.AnotherExampleBean"
									/>
									public
									classAnotherExampleBean
									implementsDisposableBean {
									public
									voiddestroy() {
									// do some destruction work (like releasing pooled connections)} }

but does not couple the code to Spring.

[Tip] Tip

The destroy-methodattribute of a <bean>element can be assigned a special (inferred)value which instructs Spring to automatically detect a public closeor shutdownmethod on the specific bean class (any class that implements java.lang.AutoCloseableor java.io.Closeablewould therefore match). This special (inferred)value can also be set on the default-destroy-methodattribute of a <beans>element to apply this behavior to an entire set of beans (see the section called “Default initialization and destroy methods”). Note that this is the default behavior with Java config.

Default initialization and destroy methods

When you write initialization and destroy method callbacks that do not use the Spring-specific InitializingBeanand DisposableBeancallback interfaces, you typically write methods with names such as init(), initialize(), dispose(), and so on. Ideally, the names of such lifecycle callback methods are standardized across a project so that all developers use the same method names and ensure consistency.

You can configure the Spring container to lookfor named initialization and destroy callback method names on everybean. This means that you, as an application developer, can write your application classes and use an initialization callback called init(), without having to configure an init-method="init"attribute with each bean definition. The Spring IoC container calls that method when the bean is created (and in accordance with the standard lifecycle callback contract described previously). This feature also enforces a consistent naming convention for initialization and destroy method callbacks.

Suppose that your initialization callback methods are named init()and destroy callback methods are named destroy(). Your class will resemble the class in the following example.

									public
									classDefaultBlogService
									implementsBlogService {
									privateBlogDao blogDao;
									public
									voidsetBlogDao(BlogDao blogDao) {
									this.blogDao = blogDao; }
									// this is (unsurprisingly) the initialization callback method
									public
									voidinit() {
									if(
									this.blogDao == null) {
									throw
									newIllegalStateException(
									"The [blogDao] property must be set."); } } }
									<beans
									default-init-method=
									"init"
									>
									<bean
									id=
									"blogService"
									class=
									"com.foo.DefaultBlogService"
									>
									<property
									name=
									"blogDao"
									ref=
									"blogDao"
									/>
									</bean>
									</beans>

The presence of the default-init-methodattribute on the top-level <beans/>element attribute causes the Spring IoC container to recognize a method called initon beans as the initialization method callback. When a bean is created and assembled, if the bean class has such a method, it is invoked at the appropriate time.

You configure destroy method callbacks similarly (in XML, that is) by using the default-destroy-methodattribute on the top-level <beans/>element.

Where existing bean classes already have callback methods that are named at variance with the convention, you can override the default by specifying (in XML, that is) the method name using the init-methodand destroy-methodattributes of the <bean/>itself.

The Spring container guarantees that a configured initialization callback is called immediately after a bean is supplied with all dependencies. Thus the initialization callback is called on the raw bean reference, which means that AOP interceptors and so forth are not yet applied to the bean. A target bean is fully created first, thenan AOP proxy (for example) with its interceptor chain is applied. If the target bean and the proxy are defined separately, your code can even interact with the raw target bean, bypassing the proxy. Hence, it would be inconsistent to apply the interceptors to the init method, because doing so would couple the lifecycle of the target bean with its proxy/interceptors and leave strange semantics when your code interacts directly to the raw target bean.

Combining lifecycle mechanisms

As of Spring 2.5, you have three options for controlling bean lifecycle behavior: the InitializingBeanand DisposableBeancallback interfaces; custom init()and destroy()methods; and the @PostConstructand @PreDestroyannotations. You can combine these mechanisms to control a given bean.

[Note] Note

If multiple lifecycle mechanisms are configured for a bean, and each mechanism is configured with a different method name, then each configured method is executed in the order listed below. However, if the same method name is configured - for example, init()for an initialization method - for more than one of these lifecycle mechanisms, that method is executed once, as explained in the preceding section.

Multiple lifecycle mechanisms configured for the same bean, with different initialization methods, are called as follows:

  • Methods annotated with @PostConstruct
  • afterPropertiesSet()as defined by the InitializingBeancallback interface
  • A custom configured init()method

Destroy methods are called in the same order:

  • Methods annotated with @PreDestroy
  • destroy()as defined by the DisposableBeancallback interface
  • A custom configured destroy()method

Startup and shutdown callbacks

The Lifecycleinterface defines the essential methods for any object that has its own lifecycle requirements (e.g. starts and stops some background process):

									public
									interfaceLifecycle {
									voidstart();
									voidstop();
									booleanisRunning(); }

Any Spring-managed object may implement that interface. Then, when the ApplicationContextitself receives start and stop signals, e.g. for a stop/restart scenario at runtime, it will cascade those calls to all Lifecycleimplementations defined within that context. It does this by delegating to a LifecycleProcessor:

									public
									interfaceLifecycleProcessor
									extendsLifecycle {
									voidonRefresh();
									voidonClose(); }

Notice that the LifecycleProcessoris itself an extension of the Lifecycleinterface. It also adds two other methods for reacting to the context being refreshed and closed.

[Tip] Tip

Note that the regular org.springframework.context.Lifecycleinterface is just a plain contract for explicit start/stop notifications and does NOT imply auto-startup at context refresh time. Consider implementing org.springframework.context.SmartLifecycleinstead for fine-grained control over auto-startup of a specific bean (including startup phases). Also, please note that stop notifications are not guaranteed to come before destruction: On regular shutdown, all Lifecyclebeans will first receive a stop notification before the general destruction callbacks are being propagated; however, on hot refresh during a context’s lifetime or on aborted refresh attempts, only destroy methods will be called.

The order of startup and shutdown invocations can be important. If a "depends-on" relationship exists between any two objects, the dependent side will start afterits dependency, and it will stop beforeits dependency. However, at times the direct dependencies are unknown. You may only know that objects of a certain type should start prior to objects of another type. In those cases, the SmartLifecycleinterface defines another option, namely the getPhase()method as defined on its super-interface, Phased.

									public
									interfacePhased {
									intgetPhase(); }
									public
									interfaceSmartLifecycle
									extendsLifecycle, Phased {
									booleanisAutoStartup();
									voidstop(Runnable callback); }

When starting, the objects with the lowest phase start first, and when stopping, the reverse order is followed. Therefore, an object that implements SmartLifecycleand whose getPhase()method returns Integer.MIN_VALUEwould be among the first to start and the last to stop. At the other end of the spectrum, a phase value of Integer.MAX_VALUEwould indicate that the object should be started last and stopped first (likely because it depends on other processes to be running). When considering the phase value, it’s also important to know that the default phase for any "normal" Lifecycleobject that does not implement SmartLifecyclewould be 0. Therefore, any negative phase value would indicate that an object should start before those standard components (and stop after them), and vice versa for any positive phase value.

As you can see the stop method defined by SmartLifecycleaccepts a callback. Any implementation mustinvoke that callback’s run()method after that implementation’s shutdown process is complete. That enables asynchronous shutdown where necessary since the default implementation of the LifecycleProcessorinterface, DefaultLifecycleProcessor, will wait up to its timeout value for the group of objects within each phase to invoke that callback. The default per-phase timeout is 30 seconds. You can override the default lifecycle processor instance by defining a bean named "lifecycleProcessor" within the context. If you only want to modify the timeout, then defining the following would be sufficient:

									<bean
									id=
									"lifecycleProcessor"
									class=
									"org.springframework.context.support.DefaultLifecycleProcessor"
									>
									<!-- timeout value in milliseconds -->
									<property
									name=
									"timeoutPerShutdownPhase"
									value=
									"10000"
									/>
									</bean>

As mentioned, the LifecycleProcessorinterface defines callback methods for the refreshing and closing of the context as well. The latter will simply drive the shutdown process as if stop()had been called explicitly, but it will happen when the context is closing. The 'refresh' callback on the other hand enables another feature of SmartLifecyclebeans. When the context is refreshed (after all objects have been instantiated and initialized), that callback will be invoked, and at that point the default lifecycle processor will check the boolean value returned by each SmartLifecycleobject’s isAutoStartup()method. If "true", then that object will be started at that point rather than waiting for an explicit invocation of the context’s or its own start()method (unlike the context refresh, the context start does not happen automatically for a standard context implementation). The "phase" value as well as any "depends-on" relationships will determine the startup order in the same way as described above.

Shutting down the Spring IoC container gracefully in non-web applications

[Note] Note

This section applies only to non-web applications. Spring’s web-based ApplicationContextimplementations already have code in place to shut down the Spring IoC container gracefully when the relevant web application is shut down.

If you are using Spring’s IoC container in a non-web application environment; for example, in a rich client desktop environment; you register a shutdown hook with the JVM. Doing so ensures a graceful shutdown and calls the relevant destroy methods on your singleton beans so that all resources are released. Of course, you must still configure and implement these destroy callbacks correctly.

To register a shutdown hook, you call the registerShutdownHook()method that is declared on the ConfigurableApplicationContextinterface:

									importorg.springframework.context.ConfigurableApplicationContext;
									importorg.springframework.context.support.ClassPathXmlApplicationContext;
									public
									final
									classBoot {
									public
									static
									voidmain(
									finalString[] args)
									throwsException { ConfigurableApplicationContext ctx =
									newClassPathXmlApplicationContext(
									newString []{
									"beans.xml"});
									// add a shutdown hook for the above context...ctx.registerShutdownHook();
									// app runs here...
									// main method exits, hook is called prior to the app shutting down...} }

7.6.2 ApplicationContextAware and BeanNameAware

When an ApplicationContextcreates an object instance that implements the org.springframework.context.ApplicationContextAwareinterface, the instance is provided with a reference to that ApplicationContext.

								public
								interfaceApplicationContextAware {
								voidsetApplicationContext(ApplicationContext applicationContext)
								throwsBeansException; }

Thus beans can manipulate programmatically the ApplicationContextthat created them, through the ApplicationContextinterface, or by casting the reference to a known subclass of this interface, such as ConfigurableApplicationContext, which exposes additional functionality. One use would be the programmatic retrieval of other beans. Sometimes this capability is useful; however, in general you should avoid it, because it couples the code to Spring and does not follow the Inversion of Control style, where collaborators are provided to beans as properties. Other methods of the ApplicationContextprovide access to file resources, publishing application events, and accessing a MessageSource. These additional features are described in Section 7.15, “Additional Capabilities of the ApplicationContext”

As of Spring 2.5, autowiring is another alternative to obtain reference to the ApplicationContext. The "traditional" constructorand byTypeautowiring modes (as described in Section 7.4.5, “Autowiring collaborators”) can provide a dependency of type ApplicationContextfor a constructor argument or setter method parameter, respectively. For more flexibility, including the ability to autowire fields and multiple parameter methods, use the new annotation-based autowiring features. If you do, the ApplicationContextis autowired into a field, constructor argument, or method parameter that is expecting the ApplicationContexttype if the field, constructor, or method in question carries the @Autowiredannotation. For more information, see Section 7.9.2, “@Autowired”.

When an ApplicationContextcreates a class that implements the org.springframework.beans.factory.BeanNameAwareinterface, the class is provided with a reference to the name defined in its associated object definition.

								public
								interfaceBeanNameAware {
								voidsetBeanName(String name)
								throwsBeansException; }

The callback is invoked after population of normal bean properties but before an initialization callback such as InitializingBean afterPropertiesSetor a custom init-method.

7.6.3 Other Aware interfaces

Besides ApplicationContextAwareand BeanNameAwarediscussed above, Spring offers a range of Awareinterfaces that allow beans to indicate to the container that they require a certain infrastructuredependency. The most important Awareinterfaces are summarized below - as a general rule, the name is a good indication of the dependency type:

Table 7.4. Aware interfaces

Name Injected Dependency Explained in…​

ApplicationContextAware

Declaring ApplicationContext

Section 7.6.2, “ApplicationContextAware and BeanNameAware”

ApplicationEventPublisherAware

Event publisher of the enclosing ApplicationContext

Section 7.15, “Additional Capabilities of the ApplicationContext”

BeanClassLoaderAware

Class loader used to load the bean classes.

Section 7.3.2, “Instantiating beans”

BeanFactoryAware

Declaring BeanFactory

Section 7.6.2, “ApplicationContextAware and BeanNameAware”

BeanNameAware

Name of the declaring bean

Section 7.6.2, “ApplicationContextAware and BeanNameAware”

BootstrapContextAware

Resource adapter BootstrapContextthe container runs in. Typically available only in JCA aware ApplicationContexts

Chapter 32, JCA CCI

LoadTimeWeaverAware

Defined weaverfor processing class definition at load time

Section 11.8.4, “Load-time weaving with AspectJ in the Spring Framework”

MessageSourceAware

Configured strategy for resolving messages (with support for parametrization and internationalization)

Section 7.15, “Additional Capabilities of the ApplicationContext”

NotificationPublisherAware

Spring JMX notification publisher

Section 31.7, “Notifications”

PortletConfigAware

Current PortletConfigthe container runs in. Valid only in a web-aware Spring ApplicationContext

Chapter 25, Portlet MVC Framework

PortletContextAware

Current PortletContextthe container runs in. Valid only in a web-aware Spring ApplicationContext

Chapter 25, Portlet MVC Framework

ResourceLoaderAware

Configured loader for low-level access to resources

Chapter 8, Resources

ServletConfigAware

Current ServletConfigthe container runs in. Valid only in a web-aware Spring ApplicationContext

Chapter 22, Web MVC framework

ServletContextAware

Current ServletContextthe container runs in. Valid only in a web-aware Spring ApplicationContext

Chapter 22, Web MVC framework


Note again that usage of these interfaces ties your code to the Spring API and does not follow the Inversion of Control style. As such, they are recommended for infrastructure beans that require programmatic access to the container.

7.7 Bean definition inheritance

A bean definition can contain a lot of configuration information, including constructor arguments, property values, and container-specific information such as initialization method, static factory method name, and so on. A child bean definition inherits configuration data from a parent definition. The child definition can override some values, or add others, as needed. Using parent and child bean definitions can save a lot of typing. Effectively, this is a form of templating.

If you work with an ApplicationContextinterface programmatically, child bean definitions are represented by the ChildBeanDefinitionclass. Most users do not work with them on this level, instead configuring bean definitions declaratively in something like the ClassPathXmlApplicationContext. When you use XML-based configuration metadata, you indicate a child bean definition by using the parentattribute, specifying the parent bean as the value of this attribute.

							<bean
							id=
							"inheritedTestBean"
							abstract=
							"true"
							class=
							"org.springframework.beans.TestBean"
							>
							<property
							name=
							"name"
							value=
							"parent"
							/>
							<property
							name=
							"age"
							value=
							"1"
							/>
							</bean>
							<bean
							id=
							"inheritsWithDifferentClass"
							class=
							"org.springframework.beans.DerivedTestBean"
							
								parent="inheritedTestBean"init-method="initialize">
							<property
							name=
							"name"
							value=
							"override"
							/>
							<!-- the age property value of 1 will be inherited from parent -->
							</bean>

A child bean definition uses the bean class from the parent definition if none is specified, but can also override it. In the latter case, the child bean class must be compatible with the parent, that is, it must accept the parent’s property values.

A child bean definition inherits scope, constructor argument values, property values, and method overrides from the parent, with the option to add new values. Any scope, initialization method, destroy method, and/or staticfactory method settings that you specify will override the corresponding parent settings.

The remaining settings are alwaystaken from the child definition: depends on, autowire mode, dependency check, singleton, lazy init.

The preceding example explicitly marks the parent bean definition as abstract by using the abstractattribute. If the parent definition does not specify a class, explicitly marking the parent bean definition as abstractis required, as follows:

							<bean
							id=
							"inheritedTestBeanWithoutClass"
							abstract=
							"true"
							>
							<property
							name=
							"name"
							value=
							"parent"
							/>
							<property
							name=
							"age"
							value=
							"1"
							/>
							</bean>
							<bean
							id=
							"inheritsWithClass"
							class=
							"org.springframework.beans.DerivedTestBean"
							parent=
							"inheritedTestBeanWithoutClass"
							init-method=
							"initialize"
							>
							<property
							name=
							"name"
							value=
							"override"
							/>
							<!-- age will inherit the value of 1 from the parent bean definition-->
							</bean>

The parent bean cannot be instantiated on its own because it is incomplete, and it is also explicitly marked as abstract. When a definition is abstractlike this, it is usable only as a pure template bean definition that serves as a parent definition for child definitions. Trying to use such an abstractparent bean on its own, by referring to it as a ref property of another bean or doing an explicit getBean()call with the parent bean id, returns an error. Similarly, the container’s internal preInstantiateSingletons()method ignores bean definitions that are defined as abstract.

[Note] Note

ApplicationContextpre-instantiates all singletons by default. Therefore, it is important (at least for singleton beans) that if you have a (parent) bean definition which you intend to use only as a template, and this definition specifies a class, you must make sure to set the abstractattribute to true, otherwise the application context will actually (attempt to) pre-instantiate the abstractbean.

7.8 Container Extension Points

Typically, an application developer does not need to subclass ApplicationContextimplementation classes. Instead, the Spring IoC container can be extended by plugging in implementations of special integration interfaces. The next few sections describe these integration interfaces.

7.8.1 Customizing beans using a BeanPostProcessor

The BeanPostProcessorinterface defines callback methodsthat you can implement to provide your own (or override the container’s default) instantiation logic, dependency-resolution logic, and so forth. If you want to implement some custom logic after the Spring container finishes instantiating, configuring, and initializing a bean, you can plug in one or more BeanPostProcessorimplementations.

You can configure multiple BeanPostProcessorinstances, and you can control the order in which these BeanPostProcessors execute by setting the orderproperty. You can set this property only if the BeanPostProcessorimplements the Orderedinterface; if you write your own BeanPostProcessoryou should consider implementing the Orderedinterface too. For further details, consult the javadocs of the BeanPostProcessorand Orderedinterfaces. See also the note below on programmatic registration of BeanPostProcessors.

[Note] Note

BeanPostProcessors operate on bean (or object) instances; that is to say, the Spring IoC container instantiates a bean instance and then BeanPostProcessors do their work.

BeanPostProcessors are scoped per-container. This is only relevant if you are using container hierarchies. If you define a BeanPostProcessorin one container, it will onlypost-process the beans in that container. In other words, beans that are defined in one container are not post-processed by a BeanPostProcessordefined in another container, even if both containers are part of the same hierarchy.

To change the actual bean definition (i.e., the blueprintthat defines the bean), you instead need to use a BeanFactoryPostProcessoras described in Section 7.8.2, “Customizing configuration metadata with a BeanFactoryPostProcessor”.

The org.springframework.beans.factory.config.BeanPostProcessorinterface consists of exactly two callback methods. When such a class is registered as a post-processor with the container, for each bean instance that is created by the container, the post-processor gets a callback from the container both beforecontainer initialization methods (such as InitializingBean’s afterPropertiesSet()and any declared init method) are called as well as afterany bean initialization callbacks. The post-processor can take any action with the bean instance, including ignoring the callback completely. A bean post-processor typically checks for callback interfaces or may wrap a bean with a proxy. Some Spring AOP infrastructure classes are implemented as bean post-processors in order to provide proxy-wrapping logic.

An ApplicationContext automatically detectsany beans that are defined in the configuration metadata which implement the BeanPostProcessorinterface. The ApplicationContextregisters these beans as post-processors so that they can be called later upon bean creation. Bean post-processors can be deployed in the container just like any other beans.

Note that when declaring a BeanPostProcessorusing an @Beanfactory method on a configuration class, the return type of the factory method should be the implementation class itself or at least the org.springframework.beans.factory.config.BeanPostProcessorinterface, clearly indicating the post-processor nature of that bean. Otherwise, the ApplicationContextwon’t be able to autodetect it by type before fully creating it. Since a BeanPostProcessorneeds to be instantiated early in order to apply to the initialization of other beans in the context, this early type detection is critical.

[Note] Programmatically registering BeanPostProcessors

While the recommended approach for BeanPostProcessorregistration is through ApplicationContextauto-detection (as described above), it is also possible to register them programmaticallyagainst a ConfigurableBeanFactoryusing the addBeanPostProcessormethod. This can be useful when needing to evaluate conditional logic before registration, or even for copying bean post processors across contexts in a hierarchy. Note however that BeanPostProcessors added programmatically do not respect the Orderedinterface. Here it is the order of registrationthat dictates the order of execution. Note also that BeanPostProcessors registered programmatically are always processed before those registered through auto-detection, regardless of any explicit ordering.
[Note] BeanPostProcessors and AOP auto-proxying

Classes that implement the BeanPostProcessorinterface are specialand are treated differently by the container. All BeanPostProcessors and beans that they reference directlyare instantiated on startup, as part of the special startup phase of the ApplicationContext. Next, all BeanPostProcessors are registered in a sorted fashion and applied to all further beans in the container. Because AOP auto-proxying is implemented as a BeanPostProcessoritself, neither BeanPostProcessors nor the beans they reference directly are eligible for auto-proxying, and thus do not have aspects woven into them.

For any such bean, you should see an informational log message: " Bean foo is not eligible for getting processed by all BeanPostProcessor interfaces (for example: not eligible for auto-proxying)".

Note that if you have beans wired into your BeanPostProcessorusing autowiring or @Resource(which may fall back to autowiring), Spring might access unexpected beans when searching for type-matching dependency candidates, and therefore make them ineligible for auto-proxying or other kinds of bean post-processing. For example, if you have a dependency annotated with @Resourcewhere the field/setter name does not directly correspond to the declared name of a bean and no name attribute is used, then Spring will access other beans for matching them by type.

The following examples show how to write, register, and use BeanPostProcessors in an ApplicationContext.

Example: Hello World, BeanPostProcessor-style

This first example illustrates basic usage. The example shows a custom BeanPostProcessorimplementation that invokes the toString()method of each bean as it is created by the container and prints the resulting string to the system console.

Find below the custom BeanPostProcessorimplementation class definition:

									packagescripting;
									importorg.springframework.beans.factory.config.BeanPostProcessor;
									importorg.springframework.beans.BeansException;
									public
									classInstantiationTracingBeanPostProcessor
									implementsBeanPostProcessor {
									// simply return the instantiated bean as-is
									publicObject postProcessBeforeInitialization(Object bean, String beanName)
									throwsBeansException {
									returnbean;
									// we could potentially return any object reference here...}
									publicObject postProcessAfterInitialization(Object bean, String beanName)
									throwsBeansException { System.out.println(
									"Bean '"+ beanName +
									"' created : "+ bean.toString());
									returnbean; } }
									<?xml version="1.0" encoding="UTF-8"?>
									<beans
									xmlns=
									"http://www.springframework.org/schema/beans"
									xmlns:xsi=
									"http://www.w3.org/2001/XMLSchema-instance"
									xmlns:lang=
									"http://www.springframework.org/schema/lang"
									xsi:schemaLocation=
									"http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/lang http://www.springframework.org/schema/lang/spring-lang.xsd"
									>
									<lang:groovy
									id=
									"messenger"
									script-source=
									"classpath:org/springframework/scripting/groovy/Messenger.groovy"
									>
									<lang:property
									name=
									"message"
									value=
									"Fiona Apple Is Just So Dreamy."
									/>
									</lang:groovy>
									<!-- when the above bean (messenger) is instantiated, this custom BeanPostProcessor implementation will output the fact to the system console -->
									<bean
									class=
									"scripting.InstantiationTracingBeanPostProcessor"
									/>
									</beans>

Notice how the InstantiationTracingBeanPostProcessoris simply defined. It does not even have a name, and because it is a bean it can be dependency-injected just like any other bean. (The preceding configuration also defines a bean that is backed by a Groovy script. The Spring dynamic language support is detailed in the chapter entitled Chapter 35, Dynamic language support .)

The following simple Java application executes the preceding code and configuration:

									importorg.springframework.context.ApplicationContext;
									importorg.springframework.context.support.ClassPathXmlApplicationContext;
									importorg.springframework.scripting.Messenger;
									public
									final
									classBoot {
									public
									static
									voidmain(
									finalString[] args)
									throwsException { ApplicationContext ctx =
									newClassPathXmlApplicationContext(
									"scripting/beans.xml"); Messenger messenger = (Messenger) ctx.getBean(
									"messenger"); System.out.println(messenger); } }

The output of the preceding application resembles the following:

Bean 'messenger' created : org.springframework.scripting.groovy.GroovyMessenger@272961 org.springframework.scripting.groovy.GroovyMessenger@272961

Example: The RequiredAnnotationBeanPostProcessor

Using callback interfaces or annotations in conjunction with a custom BeanPostProcessorimplementation is a common means of extending the Spring IoC container. An example is Spring’s RequiredAnnotationBeanPostProcessor- a BeanPostProcessorimplementation that ships with the Spring distribution which ensures that JavaBean properties on beans that are marked with an (arbitrary) annotation are actually (configured to be) dependency-injected with a value.

7.8.2 Customizing configuration metadata with a BeanFactoryPostProcessor

The next extension point that we will look at is the org.springframework.beans.factory.config.BeanFactoryPostProcessor. The semantics of this interface are similar to those of the BeanPostProcessor, with one major difference: BeanFactoryPostProcessoroperates on the bean configuration metadata; that is, the Spring IoC container allows a BeanFactoryPostProcessorto read the configuration metadata and potentially change it beforethe container instantiates any beans other than BeanFactoryPostProcessors.

You can configure multiple BeanFactoryPostProcessors, and you can control the order in which these BeanFactoryPostProcessors execute by setting the orderproperty. However, you can only set this property if the BeanFactoryPostProcessorimplements the Orderedinterface. If you write your own BeanFactoryPostProcessor, you should consider implementing the Orderedinterface too. Consult the javadocs of the BeanFactoryPostProcessorand Orderedinterfaces for more details.

[Note] Note

If you want to change the actual bean instances(i.e., the objects that are created from the configuration metadata), then you instead need to use a BeanPostProcessor(described above in Section 7.8.1, “Customizing beans using a BeanPostProcessor”). While it is technically possible to work with bean instances within a BeanFactoryPostProcessor(e.g., using BeanFactory.getBean()), doing so causes premature bean instantiation, violating the standard container lifecycle. This may cause negative side effects such as bypassing bean post processing.

Also, BeanFactoryPostProcessors are scoped per-container. This is only relevant if you are using container hierarchies. If you define a BeanFactoryPostProcessorin one container, it will onlybe applied to the bean definitions in that container. Bean definitions in one container will not be post-processed by BeanFactoryPostProcessors in another container, even if both containers are part of the same hierarchy.

A bean factory post-processor is executed automatically when it is declared inside an ApplicationContext, in order to apply changes to the configuration metadata that define the container. Spring includes a number of predefined bean factory post-processors, such as PropertyOverrideConfigurerand PropertyPlaceholderConfigurer. A custom BeanFactoryPostProcessorcan also be used, for example, to register custom property editors.

An ApplicationContextautomatically detects any beans that are deployed into it that implement the BeanFactoryPostProcessorinterface. It uses these beans as bean factory post-processors, at the appropriate time. You can deploy these post-processor beans as you would any other bean.

[Note] Note

As with BeanPostProcessors , you typically do not want to configure BeanFactoryPostProcessors for lazy initialization. If no other bean references a Bean(Factory)PostProcessor, that post-processor will not get instantiated at all. Thus, marking it for lazy initialization will be ignored, and the Bean(Factory)PostProcessorwill be instantiated eagerly even if you set the default-lazy-initattribute to trueon the declaration of your <beans />element.

Example: the Class name substitution PropertyPlaceholderConfigurer

You use the PropertyPlaceholderConfigurerto externalize property values from a bean definition in a separate file using the standard Java Propertiesformat. Doing so enables the person deploying an application to customize environment-specific properties such as database URLs and passwords, without the complexity or risk of modifying the main XML definition file or files for the container.

Consider the following XML-based configuration metadata fragment, where a DataSourcewith placeholder values is defined. The example shows properties configured from an external Propertiesfile. At runtime, a PropertyPlaceholderConfigureris applied to the metadata that will replace some properties of the DataSource. The values to replace are specified as placeholdersof the form ${property-name}which follows the Ant / log4j / JSP EL style.

									<bean
									class=
									"org.springframework.beans.factory.config.PropertyPlaceholderConfigurer"
									>
									<property
									name=
									"locations"
									value=
									"classpath:com/foo/jdbc.properties"
									/>
									</bean>
									<bean
									id=
									"dataSource"
									destroy-method=
									"close"
									class=
									"org.apache.commons.dbcp.BasicDataSource"
									>
									<property
									name=
									"driverClassName"
									value=
									"${jdbc.driverClassName}"
									/>
									<property
									name=
									"url"
									value=
									"${jdbc.url}"
									/>
									<property
									name=
									"username"
									value=
									"${jdbc.username}"
									/>
									<property
									name=
									"password"
									value=
									"${jdbc.password}"
									/>
									</bean>

The actual values come from another file in the standard Java Propertiesformat:

jdbc.driverClassName=org.hsqldb.jdbcDriver jdbc.url=jdbc:hsqldb:hsql://production:9002 jdbc.username=sa jdbc.password=root

Therefore, the string ${jdbc.username}is replaced at runtime with the value 'sa', and the same applies for other placeholder values that match keys in the properties file. The PropertyPlaceholderConfigurerchecks for placeholders in most properties and attributes of a bean definition. Furthermore, the placeholder prefix and suffix can be customized.

With the contextnamespace introduced in Spring 2.5, it is possible to configure property placeholders with a dedicated configuration element. One or more locations can be provided as a comma-separated list in the locationattribute.

									<context:property-placeholder
									location=
									"classpath:com/foo/jdbc.properties"
									/>

The PropertyPlaceholderConfigurernot only looks for properties in the Propertiesfile you specify. By default it also checks against the Java Systemproperties if it cannot find a property in the specified properties files. You can customize this behavior by setting the systemPropertiesModeproperty of the configurer with one of the following three supported integer values:

  • never(0): Never check system properties
  • fallback(1): Check system properties if not resolvable in the specified properties files. This is the default.
  • override(2): Check system properties first, before trying the specified properties files. This allows system properties to override any other property source.

Consult the PropertyPlaceholderConfigurerjavadocs for more information.

[Tip] Tip

You can use the PropertyPlaceholderConfigurerto substitute class names, which is sometimes useful when you have to pick a particular implementation class at runtime. For example:

													<bean
													class=
													"org.springframework.beans.factory.config.PropertyPlaceholderConfigurer"
													>
													<property
													name=
													"locations"
													>
													<value>classpath:com/foo/strategy.properties
													</value>
													</property>
													<property
													name=
													"properties"
													>
													<value>custom.strategy.class=com.foo.DefaultStrategy
													</value>
													</property>
													</bean>
													<bean
													id=
													"serviceStrategy"
													class=
													"${custom.strategy.class}"
													/>

If the class cannot be resolved at runtime to a valid class, resolution of the bean fails when it is about to be created, which is during the preInstantiateSingletons()phase of an ApplicationContextfor a non-lazy-init bean.

Example: the PropertyOverrideConfigurer

The PropertyOverrideConfigurer, another bean factory post-processor, resembles the PropertyPlaceholderConfigurer, but unlike the latter, the original definitions can have default values or no values at all for bean properties. If an overriding Propertiesfile does not have an entry for a certain bean property, the default context definition is used.

Note that the bean definition is notaware of being overridden, so it is not immediately obvious from the XML definition file that the override configurer is being used. In case of multiple PropertyOverrideConfigurerinstances that define different values for the same bean property, the last one wins, due to the overriding mechanism.

Properties file configuration lines take this format:

beanName.property=value

For example:

dataSource.driverClassName=com.mysql.jdbc.Driver dataSource.url=jdbc:mysql:mydb

This example file can be used with a container definition that contains a bean called dataSource, which has driverand urlproperties.

Compound property names are also supported, as long as every component of the path except the final property being overridden is already non-null (presumably initialized by the constructors). In this example…​

foo.fred.bob.sammy=123
  1. the sammyproperty of the bobproperty of the fredproperty of the foobean is set to the scalar value 123.
[Note] Note

Specified override values are always literalvalues; they are not translated into bean references. This convention also applies when the original value in the XML bean definition specifies a bean reference.

With the contextnamespace introduced in Spring 2.5, it is possible to configure property overriding with a dedicated configuration element:

									<context:property-override
									location=
									"classpath:override.properties"
									/>

7.8.3 Customizing instantiation logic with a FactoryBean

Implement the org.springframework.beans.factory.FactoryBeaninterface for objects that are themselves factories.

The FactoryBeaninterface is a point of pluggability into the Spring IoC container’s instantiation logic. If you have complex initialization code that is better expressed in Java as opposed to a (potentially) verbose amount of XML, you can create your own FactoryBean, write the complex initialization inside that class, and then plug your custom FactoryBeaninto the container.

The FactoryBeaninterface provides three methods:

  • Object getObject(): returns an instance of the object this factory creates. The instance can possibly be shared, depending on whether this factory returns singletons or prototypes.
  • boolean isSingleton(): returns trueif this FactoryBeanreturns singletons, falseotherwise.
  • Class getObjectType(): returns the object type returned by the getObject()method or nullif the type is not known in advance.

The FactoryBeanconcept and interface is used in a number of places within the Spring Framework; more than 50 implementations of the FactoryBeaninterface ship with Spring itself.

When you need to ask a container for an actual FactoryBeaninstance itself instead of the bean it produces, preface the bean’s id with the ampersand symbol ( &) when calling the getBean()method of the ApplicationContext. So for a given FactoryBeanwith an id of myBean, invoking getBean("myBean")on the container returns the product of the FactoryBean; whereas, invoking getBean("&myBean")returns the FactoryBeaninstance itself.

7.9 Annotation-based container configuration

Are annotations better than XML for configuring Spring?

The introduction of annotation-based configurations raised the question of whether this approach is 'better' than XML. The short answer is it depends. The long answer is that each approach has its pros and cons, and usually it is up to the developer to decide which strategy suits them better. Due to the way they are defined, annotations provide a lot of context in their declaration, leading to shorter and more concise configuration. However, XML excels at wiring up components without touching their source code or recompiling them. Some developers prefer having the wiring close to the source while others argue that annotated classes are no longer POJOs and, furthermore, that the configuration becomes decentralized and harder to control.

No matter the choice, Spring can accommodate both styles and even mix them together. It’s worth pointing out that through its JavaConfigoption, Spring allows annotations to be used in a non-invasive way, without touching the target components source code and that in terms of tooling, all configuration styles are supported by the Spring Tool Suite.

An alternative to XML setups is provided by annotation-based configuration which rely on the bytecode metadata for wiring up components instead of angle-bracket declarations. Instead of using XML to describe a bean wiring, the developer moves the configuration into the component class itself by using annotations on the relevant class, method, or field declaration. As mentioned in the section called “Example: The RequiredAnnotationBeanPostProcessor”, using a BeanPostProcessorin conjunction with annotations is a common means of extending the Spring IoC container. For example, Spring 2.0 introduced the possibility of enforcing required properties with the @Requiredannotation. Spring 2.5 made it possible to follow that same general approach to drive Spring’s dependency injection. Essentially, the @Autowiredannotation provides the same capabilities as described in Section 7.4.5, “Autowiring collaborators”but with more fine-grained control and wider applicability. Spring 2.5 also added support for JSR-250 annotations such as @PostConstruct, and @PreDestroy. Spring 3.0 added support for JSR-330 (Dependency Injection for Java) annotations contained in the javax.inject package such as @Injectand @Named. Details about those annotations can be found in the relevant section.

[Note] Note

Annotation injection is performed beforeXML injection, thus the latter configuration will override the former for properties wired through both approaches.

As always, you can register them as individual bean definitions, but they can also be implicitly registered by including the following tag in an XML-based Spring configuration (notice the inclusion of the contextnamespace):

							<?xml version="1.0" encoding="UTF-8"?>
							<beans
							xmlns=
							"http://www.springframework.org/schema/beans"
							xmlns:xsi=
							"http://www.w3.org/2001/XMLSchema-instance"
							xmlns:context=
							"http://www.springframework.org/schema/context"
							xsi:schemaLocation=
							"http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd"
							>
							<context:annotation-config/>
							</beans>

(The implicitly registered post-processors include AutowiredAnnotationBeanPostProcessor, CommonAnnotationBeanPostProcessor, PersistenceAnnotationBeanPostProcessor, as well as the aforementioned RequiredAnnotationBeanPostProcessor.)

[Note] Note

<context:annotation-config/>only looks for annotations on beans in the same application context in which it is defined. This means that, if you put <context:annotation-config/>in a WebApplicationContextfor a DispatcherServlet, it only checks for @Autowiredbeans in your controllers, and not your services. See Section 22.2, “The DispatcherServlet”for more information.

7.9.1 @Required

The @Requiredannotation applies to bean property setter methods, as in the following example:

								public
								classSimpleMovieLister {
								privateMovieFinder movieFinder;
								
									@Required
								public
								voidsetMovieFinder(MovieFinder movieFinder) {
								this.movieFinder = movieFinder; }
								// ...}

This annotation simply indicates that the affected bean property must be populated at configuration time, through an explicit property value in a bean definition or through autowiring. The container throws an exception if the affected bean property has not been populated; this allows for eager and explicit failure, avoiding NullPointerExceptions or the like later on. It is still recommended that you put assertions into the bean class itself, for example, into an init method. Doing so enforces those required references and values even when you use the class outside of a container.

7.9.2 @Autowired

[Note] Note

JSR 330’s @Injectannotation can be used in place of Spring’s @Autowiredannotation in the examples below. See herefor more details.

You can apply the @Autowiredannotation to constructors:

								public
								classMovieRecommender {
								private
								finalCustomerPreferenceDao customerPreferenceDao;
								
									@Autowired
								publicMovieRecommender(CustomerPreferenceDao customerPreferenceDao) {
								this.customerPreferenceDao = customerPreferenceDao; }
								// ...}
[Note] Note

As of Spring Framework 4.3, the @Autowiredconstructor is no longer necessary if the target bean only defines one constructor. If several constructors are available, at least one must be annotated to teach the container which one it has to use.

As expected, you can also apply the @Autowiredannotation to "traditional" setter methods:

								public
								classSimpleMovieLister {
								privateMovieFinder movieFinder;
								
									@Autowired
								public
								voidsetMovieFinder(MovieFinder movieFinder) {
								this.movieFinder = movieFinder; }
								// ...}

You can also apply the annotation to methods with arbitrary names and/or multiple arguments:

								public
								classMovieRecommender {
								privateMovieCatalog movieCatalog;
								privateCustomerPreferenceDao customerPreferenceDao;
								
									@Autowired
								public
								voidprepare(MovieCatalog movieCatalog, CustomerPreferenceDao customerPreferenceDao) {
								this.movieCatalog = movieCatalog;
								this.customerPreferenceDao = customerPreferenceDao; }
								// ...}

You can apply @Autowiredto fields as well and even mix it with constructors:

								public
								classMovieRecommender {
								private
								finalCustomerPreferenceDao customerPreferenceDao;
								
									@Autowired
								privateMovieCatalog movieCatalog;
								
									@Autowired
								publicMovieRecommender(CustomerPreferenceDao customerPreferenceDao) {
								this.customerPreferenceDao = customerPreferenceDao; }
								// ...}

It is also possible to provide allbeans of a particular type from the ApplicationContextby adding the annotation to a field or method that expects an array of that type:

								public
								classMovieRecommender {
								
									@Autowired
								privateMovieCatalog[] movieCatalogs;
								// ...}

The same applies for typed collections:

								public
								classMovieRecommender {
								privateSet<MovieCatalog> movieCatalogs;
								
									@Autowired
								public
								voidsetMovieCatalogs(Set<MovieCatalog> movieCatalogs) {
								this.movieCatalogs = movieCatalogs; }
								// ...}
[Tip] Tip

Your beans can implement the org.springframework.core.Orderedinterface or either use the @Orderor standard @Priorityannotation if you want items in the array or list to be sorted into a specific order.

Even typed Maps can be autowired as long as the expected key type is String. The Map values will contain all beans of the expected type, and the keys will contain the corresponding bean names:

								public
								classMovieRecommender {
								privateMap<String, MovieCatalog> movieCatalogs;
								
									@Autowired
								public
								voidsetMovieCatalogs(Map<String, MovieCatalog> movieCatalogs) {
								this.movieCatalogs = movieCatalogs; }
								// ...}

By default, the autowiring fails whenever zerocandidate beans are available; the default behavior is to treat annotated methods, constructors, and fields as indicating requireddependencies. This behavior can be changed as demonstrated below.

								public
								classSimpleMovieLister {
								privateMovieFinder movieFinder;
								
									@Autowired(required=false)
								public
								voidsetMovieFinder(MovieFinder movieFinder) {
								this.movieFinder = movieFinder; }
								// ...}
[Note] Note

Only one annotated constructor per-classcan be marked as required, but multiple non-required constructors can be annotated. In that case, each is considered among the candidates and Spring uses the greediestconstructor whose dependencies can be satisfied, that is the constructor that has the largest number of arguments.

@Autowired’s requiredattribute is recommended over the `@Requiredannotation. The requiredattribute indicates that the property is not required for autowiring purposes, the property is ignored if it cannot be autowired. @Required, on the other hand, is stronger in that it enforces the property that was set by any means supported by the container. If no value is injected, a corresponding exception is raised.

You can also use @Autowiredfor interfaces that are well-known resolvable dependencies: BeanFactory, ApplicationContext, Environment, ResourceLoader, ApplicationEventPublisher, and MessageSource. These interfaces and their extended interfaces, such as ConfigurableApplicationContextor ResourcePatternResolver, are automatically resolved, with no special setup necessary.

								public
								classMovieRecommender {
								
									@Autowired
								privateApplicationContext context;
								publicMovieRecommender() { }
								// ...}
[Note] Note

@Autowired, @Inject, @Resource, and @Valueannotations are handled by Spring BeanPostProcessorimplementations which in turn means that you cannotapply these annotations within your own BeanPostProcessoror BeanFactoryPostProcessortypes (if any). These types must be 'wired up' explicitly via XML or using a Spring @Beanmethod.

7.9.3 Fine-tuning annotation-based autowiring with @Primary

Because autowiring by type may lead to multiple candidates, it is often necessary to have more control over the selection process. One way to accomplish this is with Spring’s @Primaryannotation. @Primaryindicates that a particular bean should be given preference when multiple beans are candidates to be autowired to a single-valued dependency. If exactly one 'primary' bean exists among the candidates, it will be the autowired value.

Let’s assume we have the following configuration that defines firstMovieCatalogas the primary MovieCatalog.

								
									@Configuration
								public
								classMovieConfiguration {
								
									@Bean
								
									@Primary
								publicMovieCatalog firstMovieCatalog() { ... }
								
									@Bean
								publicMovieCatalog secondMovieCatalog() { ... }
								// ...}

With such configuration, the following MovieRecommenderwill be autowired with the firstMovieCatalog.

								public
								classMovieRecommender {
								
									@Autowired
								privateMovieCatalog movieCatalog;
								// ...}

The corresponding bean definitions appear as follows.

								<?xml version="1.0" encoding="UTF-8"?>
								<beans
								xmlns=
								"http://www.springframework.org/schema/beans"
								xmlns:xsi=
								"http://www.w3.org/2001/XMLSchema-instance"
								xmlns:context=
								"http://www.springframework.org/schema/context"
								xsi:schemaLocation=
								"http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd"
								>
								<context:annotation-config/>
								<bean
								class=
								"example.SimpleMovieCatalog"
								
									primary="true">
								<!-- inject any dependencies required by this bean -->
								</bean>
								<bean
								class=
								"example.SimpleMovieCatalog"
								>
								<!-- inject any dependencies required by this bean -->
								</bean>
								<bean
								id=
								"movieRecommender"
								class=
								"example.MovieRecommender"
								/>
								</beans>

7.9.4 Fine-tuning annotation-based autowiring with qualifiers

@Primaryis an effective way to use autowiring by type with several instances when one primary candidate can be determined. When more control over the selection process is required, Spring’s @Qualifierannotation can be used. You can associate qualifier values with specific arguments, narrowing the set of type matches so that a specific bean is chosen for each argument. In the simplest case, this can be a plain descriptive value:

								public
								classMovieRecommender {
								
									@Autowired
								
									@Qualifier("main")
								privateMovieCatalog movieCatalog;
								// ...}

The @Qualifierannotation can also be specified on individual constructor arguments or method parameters:

								public
								classMovieRecommender {
								privateMovieCatalog movieCatalog;
								privateCustomerPreferenceDao customerPreferenceDao;
								
									@Autowired
								public
								voidprepare(
								
									@Qualifier("main")MovieCatalog movieCatalog, CustomerPreferenceDao customerPreferenceDao) {
								this.movieCatalog = movieCatalog;
								this.customerPreferenceDao = customerPreferenceDao; }
								// ...}

The corresponding bean definitions appear as follows. The bean with qualifier value "main" is wired with the constructor argument that is qualified with the same value.

								<?xml version="1.0" encoding="UTF-8"?>
								<beans
								xmlns=
								"http://www.springframework.org/schema/beans"
								xmlns:xsi=
								"http://www.w3.org/2001/XMLSchema-instance"
								xmlns:context=
								"http://www.springframework.org/schema/context"
								xsi:schemaLocation=
								"http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd"
								>
								<context:annotation-config/>
								<bean
								class=
								"example.SimpleMovieCatalog"
								>
								
									<qualifier value="main"/>
								<!-- inject any dependencies required by this bean -->
								</bean>
								<bean
								class=
								"example.SimpleMovieCatalog"
								>
								
									<qualifier value="action"/>
								<!-- inject any dependencies required by this bean -->
								</bean>
								<bean
								id=
								"movieRecommender"
								class=
								"example.MovieRecommender"
								/>
								</beans>

For a fallback match, the bean name is considered a default qualifier value. Thus you can define the bean with an id "main" instead of the nested qualifier element, leading to the same matching result. However, although you can use this convention to refer to specific beans by name, @Autowiredis fundamentally about type-driven injection with optional semantic qualifiers. This means that qualifier values, even with the bean name fallback, always have narrowing semantics within the set of type matches; they do not semantically express a reference to a unique bean id. Good qualifier values are "main" or "EMEA" or "persistent", expressing characteristics of a specific component that are independent from the bean id, which may be auto-generated in case of an anonymous bean definition like the one in the preceding example.

Qualifiers also apply to typed collections, as discussed above, for example, to Set<MovieCatalog>. In this case, all matching beans according to the declared qualifiers are injected as a collection. This implies that qualifiers do not have to be unique; they rather simply constitute filtering criteria. For example, you can define multiple MovieCatalogbeans with the same qualifier value "action", all of which would be injected into a Set<MovieCatalog>annotated with @Qualifier("action").

[Tip] Tip

If you intend to express annotation-driven injection by name, do not primarily use @Autowired, even if is technically capable of referring to a bean name through @Qualifiervalues. Instead, use the JSR-250 @Resourceannotation, which is semantically defined to identify a specific target component by its unique name, with the declared type being irrelevant for the matching process. @Autowiredhas rather different semantics: After selecting candidate beans by type, the specified String qualifier value will be considered within those type-selected candidates only, e.g. matching an "account" qualifier against beans marked with the same qualifier label.

For beans that are themselves defined as a collection/map or array type, @Resourceis a fine solution, referring to the specific collection or array bean by unique name. That said, as of 4.3, collection/map and array types can be matched through Spring’s @Autowiredtype matching algorithm as well, as long as the element type information is preserved in @Beanreturn type signatures or collection inheritance hierarchies. In this case, qualifier values can be used to select among same-typed collections, as outlined in the previous paragraph.

As of 4.3, @Autowiredalso considers self references for injection, i.e. references back to the bean that is currently injected. Note that self injection is a fallback; regular dependencies on other components always have precedence. In that sense, self references do not participate in regular candidate selection and are therefore in particular never primary; on the contrary, they always end up as lowest precedence. In practice, use self references as a last resort only, e.g. for calling other methods on the same instance through the bean’s transactional proxy: Consider factoring out the affected methods to a separate delegate bean in such a scenario. Alternatively, use @Resourcewhich may obtain a proxy back to the current bean by its unique name.

@Autowiredapplies to fields, constructors, and multi-argument methods, allowing for narrowing through qualifier annotations at the parameter level. By contrast, @Resourceis supported only for fields and bean property setter methods with a single argument. As a consequence, stick with qualifiers if your injection target is a constructor or a multi-argument method.

You can create your own custom qualifier annotations. Simply define an annotation and provide the @Qualifierannotation within your definition:

								
									@Target({ElementType.FIELD, ElementType.PARAMETER})
								
									@Retention(RetentionPolicy.RUNTIME)
								
									@Qualifier
								public
								
									@interfaceGenre { String value(); }

Then you can provide the custom qualifier on autowired fields and parameters:

								public
								classMovieRecommender {
								
									@Autowired
								
									@Genre("Action")
								privateMovieCatalog actionCatalog;
								privateMovieCatalog comedyCatalog;
								
									@Autowired
								public
								voidsetComedyCatalog(
								
									@Genre("Comedy")MovieCatalog comedyCatalog) {
								this.comedyCatalog = comedyCatalog; }
								// ...}

Next, provide the information for the candidate bean definitions. You can add <qualifier/>tags as sub-elements of the <bean/>tag and then specify the typeand valueto match your custom qualifier annotations. The type is matched against the fully-qualified class name of the annotation. Or, as a convenience if no risk of conflicting names exists, you can use the short class name. Both approaches are demonstrated in the following example.

								<?xml version="1.0" encoding="UTF-8"?>
								<beans
								xmlns=
								"http://www.springframework.org/schema/beans"
								xmlns:xsi=
								"http://www.w3.org/2001/XMLSchema-instance"
								xmlns:context=
								"http://www.springframework.org/schema/context"
								xsi:schemaLocation=
								"http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd"
								>
								<context:annotation-config/>
								<bean
								class=
								"example.SimpleMovieCatalog"
								>
								
									<qualifier type="Genre" value="Action"/>
								<!-- inject any dependencies required by this bean -->
								</bean>
								<bean
								class=
								"example.SimpleMovieCatalog"
								>
								
									<qualifier type="example.Genre" value="Comedy"/>
								<!-- inject any dependencies required by this bean -->
								</bean>
								<bean
								id=
								"movieRecommender"
								class=
								"example.MovieRecommender"
								/>
								</beans>

In Section 7.10, “Classpath scanning and managed components”, you will see an annotation-based alternative to providing the qualifier metadata in XML. Specifically, see Section 7.10.8, “Providing qualifier metadata with annotations”.

In some cases, it may be sufficient to use an annotation without a value. This may be useful when the annotation serves a more generic purpose and can be applied across several different types of dependencies. For example, you may provide an offlinecatalog that would be searched when no Internet connection is available. First define the simple annotation:

								
									@Target({ElementType.FIELD, ElementType.PARAMETER})
								
									@Retention(RetentionPolicy.RUNTIME)
								
									@Qualifier
								public
								
									@interfaceOffline { }

Then add the annotation to the field or property to be autowired:

								public
								classMovieRecommender {
								
									@Autowired
								
									@Offline
								privateMovieCatalog offlineCatalog;
								// ...}

Now the bean definition only needs a qualifier type:

								<bean
								class=
								"example.SimpleMovieCatalog"
								>
								
									<qualifier type="Offline"/>
								<!-- inject any dependencies required by this bean -->
								</bean>

You can also define custom qualifier annotations that accept named attributes in addition to or instead of the simple valueattribute. If multiple attribute values are then specified on a field or parameter to be autowired, a bean definition must match allsuch attribute values to be considered an autowire candidate. As an example, consider the following annotation definition:

								
									@Target({ElementType.FIELD, ElementType.PARAMETER})
								
									@Retention(RetentionPolicy.RUNTIME)
								
									@Qualifier
								public
								
									@interfaceMovieQualifier { String genre(); Format format(); }

In this case Formatis an enum:

								publicenum Format { VHS, DVD, BLURAY }

The fields to be autowired are annotated with the custom qualifier and include values for both attributes: genreand format.

								public
								classMovieRecommender {
								
									@Autowired
								
									@MovieQualifier(format=Format.VHS, genre="Action")
								privateMovieCatalog actionVhsCatalog;
								
									@Autowired
								
									@MovieQualifier(format=Format.VHS, genre="Comedy")
								privateMovieCatalog comedyVhsCatalog;
								
									@Autowired
								
									@MovieQualifier(format=Format.DVD, genre="Action")
								privateMovieCatalog actionDvdCatalog;
								
									@Autowired
								
									@MovieQualifier(format=Format.BLURAY, genre="Comedy")
								privateMovieCatalog comedyBluRayCatalog;
								// ...}

Finally, the bean definitions should contain matching qualifier values. This example also demonstrates that bean metaattributes may be used instead of the <qualifier/>sub-elements. If available, the <qualifier/>and its attributes take precedence, but the autowiring mechanism falls back on the values provided within the <meta/>tags if no such qualifier is present, as in the last two bean definitions in the following example.

								<?xml version="1.0" encoding="UTF-8"?>
								<beans
								xmlns=
								"http://www.springframework.org/schema/beans"
								xmlns:xsi=
								"http://www.w3.org/2001/XMLSchema-instance"
								xmlns:context=
								"http://www.springframework.org/schema/context"
								xsi:schemaLocation=
								"http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd"
								>
								<context:annotation-config/>
								<bean
								class=
								"example.SimpleMovieCatalog"
								>
								<qualifier
								type=
								"MovieQualifier"
								>
								<attribute
								key=
								"format"
								value=
								"VHS"
								/>
								<attribute
								key=
								"genre"
								value=
								"Action"
								/>
								</qualifier>
								<!-- inject any dependencies required by this bean -->
								</bean>
								<bean
								class=
								"example.SimpleMovieCatalog"
								>
								<qualifier
								type=
								"MovieQualifier"
								>
								<attribute
								key=
								"format"
								value=
								"VHS"
								/>
								<attribute
								key=
								"genre"
								value=
								"Comedy"
								/>
								</qualifier>
								<!-- inject any dependencies required by this bean -->
								</bean>
								<bean
								class=
								"example.SimpleMovieCatalog"
								>
								<meta
								key=
								"format"
								value=
								"DVD"
								/>
								<meta
								key=
								"genre"
								value=
								"Action"
								/>
								<!-- inject any dependencies required by this bean -->
								</bean>
								<bean
								class=
								"example.SimpleMovieCatalog"
								>
								<meta
								key=
								"format"
								value=
								"BLURAY"
								/>
								<meta
								key=
								"genre"
								value=
								"Comedy"
								/>
								<!-- inject any dependencies required by this bean -->
								</bean>
								</beans>

7.9.5 Using generics as autowiring qualifiers

In addition to the @Qualifierannotation, it is also possible to use Java generic types as an implicit form of qualification. For example, suppose you have the following configuration:

								
									@Configuration
								public
								classMyConfiguration {
								
									@Bean
								publicStringStore stringStore() {
								return
								newStringStore(); }
								
									@Bean
								publicIntegerStore integerStore() {
								return
								newIntegerStore(); } }

Assuming that beans above implement a generic interface, i.e. Store<String>and Store<Integer>, you can @Autowirethe Storeinterface and the genericwill be used as a qualifier:

								
									@Autowired
								privateStore<String> s1;
								// <String> qualifier, injects the stringStore bean
								
									@Autowired
								privateStore<Integer> s2;
								// <Integer> qualifier, injects the integerStore bean

Generic qualifiers also apply when autowiring Lists, Maps and Arrays:

								// Inject all Store beans as long as they have an <Integer> generic
								// Store<String> beans will not appear in this list
								
									@Autowired
								privateList<Store<Integer>> s;

7.9.6 CustomAutowireConfigurer

The CustomAutowireConfigureris a BeanFactoryPostProcessorthat enables you to register your own custom qualifier annotation types even if they are not annotated with Spring’s @Qualifierannotation.

								<bean
								id=
								"customAutowireConfigurer"
								class=
								"org.springframework.beans.factory.annotation.CustomAutowireConfigurer"
								>
								<property
								name=
								"customQualifierTypes"
								>
								<set>
								<value>example.CustomQualifier
								</value>
								</set>
								</property>
								</bean>

The AutowireCandidateResolverdetermines autowire candidates by:

  • the autowire-candidatevalue of each bean definition
  • any default-autowire-candidatespattern(s) available on the <beans/>element
  • the presence of @Qualifierannotations and any custom annotations registered with the CustomAutowireConfigurer

When multiple beans qualify as autowire candidates, the determination of a "primary" is the following: if exactly one bean definition among the candidates has a primaryattribute set to true, it will be selected.

7.9.7 @Resource

Spring also supports injection using the JSR-250 @Resourceannotation on fields or bean property setter methods. This is a common pattern in Java EE 5 and 6, for example in JSF 1.2 managed beans or JAX-WS 2.0 endpoints. Spring supports this pattern for Spring-managed objects as well.

@Resourcetakes a name attribute, and by default Spring interprets that value as the bean name to be injected. In other words, it follows by-namesemantics, as demonstrated in this example:

								public
								classSimpleMovieLister {
								privateMovieFinder movieFinder;
								
									@Resource(name="myMovieFinder")
								public
								voidsetMovieFinder(MovieFinder movieFinder) {
								this.movieFinder = movieFinder; } }

If no name is specified explicitly, the default name is derived from the field name or setter method. In case of a field, it takes the field name; in case of a setter method, it takes the bean property name. So the following example is going to have the bean with name "movieFinder" injected into its setter method:

								public
								classSimpleMovieLister {
								privateMovieFinder movieFinder;
								
									@Resource
								public
								voidsetMovieFinder(MovieFinder movieFinder) {
								this.movieFinder = movieFinder; } }
[Note] Note

The name provided with the annotation is resolved as a bean name by the ApplicationContextof which the CommonAnnotationBeanPostProcessoris aware. The names can be resolved through JNDI if you configure Spring’s SimpleJndiBeanFactoryexplicitly. However, it is recommended that you rely on the default behavior and simply use Spring’s JNDI lookup capabilities to preserve the level of indirection.

In the exclusive case of @Resourceusage with no explicit name specified, and similar to @Autowired, @Resourcefinds a primary type match instead of a specific named bean and resolves well-known resolvable dependencies: the BeanFactory, ApplicationContext, ResourceLoader, ApplicationEventPublisher, and MessageSourceinterfaces.

Thus in the following example, the customerPreferenceDaofield first looks for a bean named customerPreferenceDao, then falls back to a primary type match for the type CustomerPreferenceDao. The "context" field is injected based on the known resolvable dependency type ApplicationContext.

								public
								classMovieRecommender {
								
									@Resource
								privateCustomerPreferenceDao customerPreferenceDao;
								
									@Resource
								privateApplicationContext context;
								publicMovieRecommender() { }
								// ...}

7.9.8 @PostConstruct and @PreDestroy

The CommonAnnotationBeanPostProcessornot only recognizes the @Resourceannotation but also the JSR-250 lifecycleannotations. Introduced in Spring 2.5, the support for these annotations offers yet another alternative to those described in initialization callbacksand destruction callbacks. Provided that the CommonAnnotationBeanPostProcessoris registered within the Spring ApplicationContext, a method carrying one of these annotations is invoked at the same point in the lifecycle as the corresponding Spring lifecycle interface method or explicitly declared callback method. In the example below, the cache will be pre-populated upon initialization and cleared upon destruction.

								public
								classCachingMovieLister {
								
									@PostConstruct
								public
								voidpopulateMovieCache() {
								// populates the movie cache upon initialization...}
								
									@PreDestroy
								public
								voidclearMovieCache() {
								// clears the movie cache upon destruction...} }
[Note] Note

For details about the effects of combining various lifecycle mechanisms, see the section called “Combining lifecycle mechanisms”.

7.10 Classpath scanning and managed components

Most examples in this chapter use XML to specify the configuration metadata that produces each BeanDefinitionwithin the Spring container. The previous section ( Section 7.9, “Annotation-based container configuration”) demonstrates how to provide a lot of the configuration metadata through source-level annotations. Even in those examples, however, the "base" bean definitions are explicitly defined in the XML file, while the annotations only drive the dependency injection. This section describes an option for implicitly detecting the candidate componentsby scanning the classpath. Candidate components are classes that match against a filter criteria and have a corresponding bean definition registered with the container. This removes the need to use XML to perform bean registration; instead you can use annotations (for example @Component), AspectJ type expressions, or your own custom filter criteria to select which classes will have bean definitions registered with the container.

[Note] Note

Starting with Spring 3.0, many features provided by the Spring JavaConfig project are part of the core Spring Framework. This allows you to define beans using Java rather than using the traditional XML files. Take a look at the @Configuration, @Bean, @Import, and @DependsOnannotations for examples of how to use these new features.

7.10.1 @Component and further stereotype annotations

The @Repositoryannotation is a marker for any class that fulfills the role or stereotypeof a repository (also known as Data Access Object or DAO). Among the uses of this marker is the automatic translation of exceptions as described in Section 20.2.2, “Exception translation”.

Spring provides further stereotype annotations: @Component, @Service, and @Controller. @Componentis a generic stereotype for any Spring-managed component. @Repository, @Service, and @Controllerare specializations of @Componentfor more specific use cases, for example, in the persistence, service, and presentation layers, respectively. Therefore, you can annotate your component classes with @Component, but by annotating them with @Repository, @Service, or @Controllerinstead, your classes are more properly suited for processing by tools or associating with aspects. For example, these stereotype annotations make ideal targets for pointcuts. It is also possible that @Repository, @Service, and @Controllermay carry additional semantics in future releases of the Spring Framework. Thus, if you are choosing between using @Componentor @Servicefor your service layer, @Serviceis clearly the better choice. Similarly, as stated above, @Repositoryis already supported as a marker for automatic exception translation in your persistence layer.

7.10.2 Meta-annotations

Many of the annotations provided by Spring can be used as meta-annotationsin your own code. A meta-annotation is simply an annotation that can be applied to another annotation. For example, the @Serviceannotation mentioned above is meta-annotated with @Component:

								
									@Target(ElementType.TYPE)
								
									@Retention(RetentionPolicy.RUNTIME)
								
									@Documented
								
									@Component
								// Spring will see this and treat @Service in the same way as @Component
								public
								
									@interfaceService {
								// ....}

Meta-annotations can also be combined to create composed annotations. For example, the @RestControllerannotation from Spring MVC is composedof @Controllerand @ResponseBody.

In addition, composed annotations may optionally redeclare attributes from meta-annotations to allow user customization. This can be particularly useful when you want to only expose a subset of the meta-annotation’s attributes. For example, Spring’s @SessionScopeannotation hardcodes the scope name to sessionbut still allows customization of the proxyMode.

								
									@Target({ElementType.TYPE, ElementType.METHOD})
								
									@Retention(RetentionPolicy.RUNTIME)
								
									@Documented
								
									@Scope(WebApplicationContext.SCOPE_SESSION)
								public
								
									@interfaceSessionScope {
								/** * Alias for {@link Scope#proxyMode}. * <p>Defaults to {@link ScopedProxyMode#TARGET_CLASS}. */
								
									@AliasFor(annotation = Scope.class)ScopedProxyMode proxyMode()
								defaultScopedProxyMode.TARGET_CLASS; }

@SessionScopecan then be used without declaring the proxyModeas follows:

								
									@Service
								
									@SessionScope
								public
								classSessionScopedService {
								// ...}

Or with an overridden value for the proxyModeas follows:

								
									@Service
								
									@SessionScope(proxyMode = ScopedProxyMode.INTERFACES)
								public
								classSessionScopedUserService
								implementsUserService {
								// ...}

For further details, consult the Spring Annotation Programming Model.

7.10.3 Automatically detecting classes and registering bean definitions

Spring can automatically detect stereotyped classes and register corresponding BeanDefinitions with the ApplicationContext. For example, the following two classes are eligible for such autodetection:

								
									@Service
								public
								classSimpleMovieLister {
								privateMovieFinder movieFinder;
								
									@Autowired
								publicSimpleMovieLister(MovieFinder movieFinder) {
								this.movieFinder = movieFinder; } }
								
									@Repository
								public
								classJpaMovieFinder
								implementsMovieFinder {
								// implementation elided for clarity}

To autodetect these classes and register the corresponding beans, you need to add @ComponentScanto your @Configurationclass, where the basePackagesattribute is a common parent package for the two classes. (Alternatively, you can specify a comma/semicolon/space-separated list that includes the parent package of each class.)

								
									@Configuration
								
									@ComponentScan(basePackages = "org.example")
								public
								classAppConfig { ... }
[Note] Note

for concision, the above may have used the valueattribute of the annotation, i.e. ComponentScan("org.example")

The following is an alternative using XML

								<?xml version="1.0" encoding="UTF-8"?>
								<beans
								xmlns=
								"http://www.springframework.org/schema/beans"
								xmlns:xsi=
								"http://www.w3.org/2001/XMLSchema-instance"
								xmlns:context=
								"http://www.springframework.org/schema/context"
								xsi:schemaLocation=
								"http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd"
								>
								<context:component-scan
								base-package=
								"org.example"
								/>
								</beans>
[Tip] Tip

The use of <context:component-scan>implicitly enables the functionality of <context:annotation-config>. There is usually no need to include the <context:annotation-config>element when using <context:component-scan>.
[Note] Note

The scanning of classpath packages requires the presence of corresponding directory entries in the classpath. When you build JARs with Ant, make sure that you do notactivate the files-only switch of the JAR task. Also, classpath directories may not get exposed based on security policies in some environments, e.g. standalone apps on JDK 1.7.0_45 and higher (which requires 'Trusted-Library' setup in your manifests; see http://stackoverflow.com/questions/19394570/java-jre-7u45-breaks-classloader-getresources).

Furthermore, the AutowiredAnnotationBeanPostProcessorand CommonAnnotationBeanPostProcessorare both included implicitly when you use the component-scan element. That means that the two components are autodetected andwired together - all without any bean configuration metadata provided in XML.

[Note] Note

You can disable the registration of AutowiredAnnotationBeanPostProcessorand CommonAnnotationBeanPostProcessorby including the annotation-configattribute with a value of false.

7.10.4 Using filters to customize scanning

By default, classes annotated with @Component, @Repository, @Service, @Controller, or a custom annotation that itself is annotated with @Componentare the only detected candidate components. However, you can modify and extend this behavior simply by applying custom filters. Add them as includeFiltersor excludeFiltersparameters of the @ComponentScanannotation (or as include-filteror exclude-filtersub-elements of the component-scanelement). Each filter element requires the typeand expressionattributes. The following table describes the filtering options.

Table 7.5. Filter Types

Filter Type Example Expression Description

annotation (default)

org.example.SomeAnnotation

An annotation to be present at the type level in target components.

assignable

org.example.SomeClass

A class (or interface) that the target components are assignable to (extend/implement).

aspectj

org.example..*Service+

An AspectJ type expression to be matched by the target components.

regex

org\.example\.Default.*

A regex expression to be matched by the target components class names.

custom

org.example.MyTypeFilter

A custom implementation of the org.springframework.core.type .TypeFilterinterface.

The following example shows the configuration ignoring all @Repositoryannotations and using "stub" repositories instead.

								
									@Configuration
								
									@ComponentScan(basePackages = "org.example", includeFilters = @Filter(type = FilterType.REGEX, pattern = ".*Stub.*Repository"), excludeFilters = @Filter(Repository.class))
								public
								classAppConfig { ... }

and the equivalent using XML

								<beans>
								<context:component-scan
								base-package=
								"org.example"
								>
								<context:include-filter
								type=
								"regex"
								expression=
								".*Stub.*Repository"
								/>
								<context:exclude-filter
								type=
								"annotation"
								expression=
								"org.springframework.stereotype.Repository"
								/>
								</context:component-scan>
								</beans>
[Note] Note

You can also disable the default filters by setting useDefaultFilters=falseon the annotation or providing use-default-filters="false"as an attribute of the <component-scan/>element. This will in effect disable automatic detection of classes annotated with @Component, @Repository, @Service, @Controller, or @Configuration.

7.10.5 Defining bean metadata within components

Spring components can also contribute bean definition metadata to the container. You do this with the same @Beanannotation used to define bean metadata within @Configurationannotated classes. Here is a simple example:

								
									@Component
								public
								classFactoryMethodComponent {
								
									@Bean
								
									@Qualifier("public")
								publicTestBean publicInstance() {
								return
								newTestBean(
								"publicInstance"); }
								public
								voiddoWork() {
								// Component method implementation omitted} }

This class is a Spring component that has application-specific code contained in its doWork()method. However, it also contributes a bean definition that has a factory method referring to the method publicInstance(). The @Beanannotation identifies the factory method and other bean definition properties, such as a qualifier value through the @Qualifierannotation. Other method level annotations that can be specified are @Scope, @Lazy, and custom qualifier annotations.

[Tip] Tip

In addition to its role for component initialization, the @Lazyannotation may also be placed on injection points marked with @Autowiredor @Inject. In this context, it leads to the injection of a lazy-resolution proxy.

Autowired fields and methods are supported as previously discussed, with additional support for autowiring of @Beanmethods:

								
									@Component
								public
								classFactoryMethodComponent {
								private
								static
								inti;
								
									@Bean
								
									@Qualifier("public")
								publicTestBean publicInstance() {
								return
								newTestBean(
								"publicInstance"); }
								// use of a custom qualifier and autowiring of method parameters
								
									@Bean
								protectedTestBean protectedInstance(
								
									@Qualifier("public")TestBean spouse,
								
									@Value("#{privateInstance.age}")String country) { TestBean tb =
								newTestBean(
								"protectedInstance",
								1); tb.setSpouse(spouse); tb.setCountry(country);
								returntb; }
								
									@Bean
								privateTestBean privateInstance() {
								return
								newTestBean(
								"privateInstance", i++); }
								
									@Bean
								
									@RequestScope
								publicTestBean requestScopedInstance() {
								return
								newTestBean(
								"requestScopedInstance",
								3); } }

The example autowires the Stringmethod parameter countryto the value of the Ageproperty on another bean named privateInstance. A Spring Expression Language element defines the value of the property through the notation #{ <expression> }. For @Valueannotations, an expression resolver is preconfigured to look for bean names when resolving expression text.

As of Spring Framework 4.3, you may also declare a factory method parameter of type InjectionPoint(or its more specific subclass DependencyDescriptor) in order to access the requesting injection point that triggers the creation of the current bean. Note that this will only apply to the actual creation of bean instances, not to the injection of existing instances. As a consequence, this feature makes most sense for beans of prototype scope. For other scopes, the factory method will only ever see the injection point which triggered the creation of a new bean instance in the given scope: for example, the dependency that triggered the creation of a lazy singleton bean. Use the provided injection point metadata with semantic care in such scenarios.

								
									@Component
								public
								classFactoryMethodComponent {
								
									@Bean
								
									@Scope("prototype")
								publicTestBean prototypeInstance(InjectionPoint injectionPoint) {
								return
								newTestBean(
								"prototypeInstance for "+ injectionPoint.getMember()); } }

The @Beanmethods in a regular Spring component are processed differently than their counterparts inside a Spring @Configurationclass. The difference is that @Componentclasses are not enhanced with CGLIB to intercept the invocation of methods and fields. CGLIB proxying is the means by which invoking methods or fields within @Beanmethods in @Configurationclasses creates bean metadata references to collaborating objects; such methods are notinvoked with normal Java semantics but rather go through the container in order to provide the usual lifecycle management and proxying of Spring beans even when referring to other beans via programmatic calls to @Beanmethods. In contrast, invoking a method or field in an @Beanmethod within a plain @Componentclass hasstandard Java semantics, with no special CGLIB processing or other constraints applying.

[Note] Note

You may declare @Beanmethods as static, allowing for them to be called without creating their containing configuration class as an instance. This makes particular sense when defining post-processor beans, e.g. of type BeanFactoryPostProcessoror BeanPostProcessor, since such beans will get initialized early in the container lifecycle and should avoid triggering other parts of the configuration at that point.

Note that calls to static @Beanmethods will never get intercepted by the container, not even within @Configurationclasses (see above). This is due to technical limitations: CGLIB subclassing can only override non-static methods. As a consequence, a direct call to another @Beanmethod will have standard Java semantics, resulting in an independent instance being returned straight from the factory method itself.

The Java language visibility of @Beanmethods does not have an immediate impact on the resulting bean definition in Spring’s container. You may freely declare your factory methods as you see fit in non- @Configurationclasses and also for static methods anywhere. However, regular @Beanmethods in @Configurationclasses need to be overridable, i.e. they must not be declared as privateor final.

@Beanmethods will also be discovered on base classes of a given component or configuration class, as well as on Java 8 default methods declared in interfaces implemented by the component or configuration class. This allows for a lot of flexibility in composing complex configuration arrangements, with even multiple inheritance being possible through Java 8 default methods as of Spring 4.2.

Finally, note that a single class may hold multiple @Beanmethods for the same bean, as an arrangement of multiple factory methods to use depending on available dependencies at runtime. This is the same algorithm as for choosing the "greediest" constructor or factory method in other configuration scenarios: The variant with the largest number of satisfiable dependencies will be picked at construction time, analogous to how the container selects between multiple @Autowiredconstructors.

7.10.6 Naming autodetected components

When a component is autodetected as part of the scanning process, its bean name is generated by the BeanNameGeneratorstrategy known to that scanner. By default, any Spring stereotype annotation ( @Component, @Repository, @Service, and @Controller) that contains a name valuewill thereby provide that name to the corresponding bean definition.

If such an annotation contains no name valueor for any other detected component (such as those discovered by custom filters), the default bean name generator returns the uncapitalized non-qualified class name. For example, if the following two components were detected, the names would be myMovieListerand movieFinderImpl:

								
									@Service("myMovieLister")
								public
								classSimpleMovieLister {
								// ...}
								
									@Repository
								public
								classMovieFinderImpl
								implementsMovieFinder {
								// ...}
[Note] Note

If you do not want to rely on the default bean-naming strategy, you can provide a custom bean-naming strategy. First, implement the BeanNameGeneratorinterface, and be sure to include a default no-arg constructor. Then, provide the fully-qualified class name when configuring the scanner:

 
								
									@Configuration
								
									@ComponentScan(basePackages = "org.example", nameGenerator = MyNameGenerator.class)
								public
								classAppConfig { ... }
								<beans>
								<context:component-scan
								base-package=
								"org.example"
								name-generator=
								"org.example.MyNameGenerator"
								/>
								</beans>

As a general rule, consider specifying the name with the annotation whenever other components may be making explicit references to it. On the other hand, the auto-generated names are adequate whenever the container is responsible for wiring.

7.10.7 Providing a scope for autodetected components

As with Spring-managed components in general, the default and most common scope for autodetected components is singleton. However, sometimes you need a different scope which can be specified via the @Scopeannotation. Simply provide the name of the scope within the annotation:

								
									@Scope("prototype")
								
									@Repository
								public
								classMovieFinderImpl
								implementsMovieFinder {
								// ...}

For details on web-specific scopes, see Section 7.5.4, “Request, session, global session, application, and WebSocket scopes”.

[Note] Note

To provide a custom strategy for scope resolution rather than relying on the annotation-based approach, implement the ScopeMetadataResolverinterface, and be sure to include a default no-arg constructor. Then, provide the fully-qualified class name when configuring the scanner:

 
								
									@Configuration
								
									@ComponentScan(basePackages = "org.example", scopeResolver = MyScopeResolver.class)
								public
								classAppConfig { ... }
								<beans>
								<context:component-scan
								base-package=
								"org.example"
								scope-resolver=
								"org.example.MyScopeResolver"
								/>
								</beans>

When using certain non-singleton scopes, it may be necessary to generate proxies for the scoped objects. The reasoning is described in the section called “Scoped beans as dependencies”. For this purpose, a scoped-proxyattribute is available on the component-scan element. The three possible values are: no, interfaces, and targetClass. For example, the following configuration will result in standard JDK dynamic proxies:

								
									@Configuration
								
									@ComponentScan(basePackages = "org.example", scopedProxy = ScopedProxyMode.INTERFACES)
								public
								classAppConfig { ... }
								<beans>
								<context:component-scan
								base-package=
								"org.example"
								scoped-proxy=
								"interfaces"
								/>
								</beans>

7.10.8 Providing qualifier metadata with annotations

The @Qualifierannotation is discussed in Section 7.9.4, “Fine-tuning annotation-based autowiring with qualifiers”. The examples in that section demonstrate the use of the @Qualifierannotation and custom qualifier annotations to provide fine-grained control when you resolve autowire candidates. Because those examples were based on XML bean definitions, the qualifier metadata was provided on the candidate bean definitions using the qualifieror metasub-elements of the beanelement in the XML. When relying upon classpath scanning for autodetection of components, you provide the qualifier metadata with type-level annotations on the candidate class. The following three examples demonstrate this technique:

								
									@Component
								
									@Qualifier("Action")
								public
								classActionMovieCatalog
								implementsMovieCatalog {
								// ...}
								
									@Component
								
									@Genre("Action")
								public
								classActionMovieCatalog
								implementsMovieCatalog {
								// ...}
								
									@Component
								
									@Offline
								public
								classCachingMovieCatalog
								implementsMovieCatalog {
								// ...}
[Note] Note

As with most annotation-based alternatives, keep in mind that the annotation metadata is bound to the class definition itself, while the use of XML allows for multiple beans of the same typeto provide variations in their qualifier metadata, because that metadata is provided per-instance rather than per-class.

7.11 Using JSR 330 Standard Annotations

Starting with Spring 3.0, Spring offers support for JSR-330 standard annotations (Dependency Injection). Those annotations are scanned in the same way as the Spring annotations. You just need to have the relevant jars in your classpath.

[Note] Note

If you are using Maven, the javax.injectartifact is available in the standard Maven repository ( http://repo1.maven.org/maven2/javax/inject/javax.inject/1/). You can add the following dependency to your file pom.xml:

											<dependency>
											<groupId>javax.inject
											</groupId>
											<artifactId>javax.inject
											</artifactId>
											<version>1
											</version>
											</dependency>

7.11.1 Dependency Injection with @Inject and @Named

Instead of @Autowired, @javax.inject.Injectmay be used as follows:

								importjavax.inject.Inject;
								public
								classSimpleMovieLister {
								privateMovieFinder movieFinder;
								
									@Inject
								public
								voidsetMovieFinder(MovieFinder movieFinder) {
								this.movieFinder = movieFinder; }
								public
								voidlistMovies() {
								this.movieFinder.findMovies(...); ... } }

As with @Autowired, it is possible to use @Injectat the field level, method level and constructor-argument level. Furthermore, you may declare your injection point as a Provider, allowing for on-demand access to beans of shorter scopes or lazy access to other beans through a Provider.get()call. As a variant of the example above:

								importjavax.inject.Inject;
								importjavax.inject.Provider;
								public
								classSimpleMovieLister {
								privateProvider<MovieFinder> movieFinder;
								public
								voidlistMovies() {
								this.movieFinder.get().findMovies(...); ... } }

If you would like to use a qualified name for the dependency that should be injected, you should use the @Namedannotation as follows:

								importjavax.inject.Inject;
								importjavax.inject.Named;
								public
								classSimpleMovieLister {
								privateMovieFinder movieFinder;
								
									@Inject
								public
								voidsetMovieFinder(
								
									@Named("main")MovieFinder movieFinder) {
								this.movieFinder = movieFinder; }
								// ...}

7.11.2 @Named and @ManagedBean: standard equivalents to the @Component annotation

Instead of @Component, @javax.inject.Namedor javax.annotation.ManagedBeanmay be used as follows:

								importjavax.inject.Inject;
								importjavax.inject.Named;
								
									@Named("movieListener")
								// @ManagedBean("movieListener") could be used as well
								public
								classSimpleMovieLister {
								privateMovieFinder movieFinder;
								
									@Inject
								public
								voidsetMovieFinder(MovieFinder movieFinder) {
								this.movieFinder = movieFinder; }
								// ...}

It is very common to use @Componentwithout specifying a name for the component. @Namedcan be used in a similar fashion:

								importjavax.inject.Inject;
								importjavax.inject.Named;
								
									@Named
								public
								classSimpleMovieLister {
								privateMovieFinder movieFinder;
								
									@Inject
								public
								voidsetMovieFinder(MovieFinder movieFinder) {
								this.movieFinder = movieFinder; }
								// ...}

When using @Namedor @ManagedBean, it is possible to use component scanning in the exact same way as when using Spring annotations:

								
									@Configuration
								
									@ComponentScan(basePackages = "org.example")
								public
								classAppConfig { ... }
[Note] Note

In contrast to @Component, the JSR-330 @Namedand the JSR-250 ManagedBeanannotations are not composable. Please use Spring’s stereotype model for building custom component annotations.

7.11.3 Limitations of JSR-330 standard annotations

When working with standard annotations, it is important to know that some significant features are not available as shown in the table below:

Table 7.6. Spring component model elements vs. JSR-330 variants

Spring javax.inject.* javax.inject restrictions / comments

@Autowired

@Inject

@Injecthas no 'required' attribute; can be used with Java 8’s Optionalinstead.

@Component

@Named / @ManagedBean

JSR-330 does not provide a composable model, just a way to identify named components.

@Scope("singleton")

@Singleton

The JSR-330 default scope is like Spring’s prototype. However, in order to keep it consistent with Spring’s general defaults, a JSR-330 bean declared in the Spring container is a singletonby default. In order to use a scope other than singleton, you should use Spring’s @Scopeannotation. javax.injectalso provides a @Scopeannotation. Nevertheless, this one is only intended to be used for creating your own annotations.

@Qualifier

@Qualifier / @Named

javax.inject.Qualifieris just a meta-annotation for building custom qualifiers. Concrete String qualifiers (like Spring’s @Qualifierwith a value) can be associated through javax.inject.Named.

@Value

-

no equivalent

@Required

-

no equivalent

@Lazy

-

no equivalent

ObjectFactory

Provider

javax.inject.Provideris a direct alternative to Spring’s ObjectFactory, just with a shorter get()method name. It can also be used in combination with Spring’s @Autowiredor with non-annotated constructors and setter methods.

7.12 Java-based container configuration

7.12.1 Basic concepts: @Bean and @Configuration

The central artifacts in Spring’s new Java-configuration support are @Configuration-annotated classes and @Bean-annotated methods.

The @Beanannotation is used to indicate that a method instantiates, configures and initializes a new object to be managed by the Spring IoC container. For those familiar with Spring’s <beans/>XML configuration the @Beanannotation plays the same role as the <bean/>element. You can use @Beanannotated methods with any Spring @Component, however, they are most often used with @Configurationbeans.

Annotating a class with @Configurationindicates that its primary purpose is as a source of bean definitions. Furthermore, @Configurationclasses allow inter-bean dependencies to be defined by simply calling other @Beanmethods in the same class. The simplest possible @Configurationclass would read as follows:

								
									@Configuration
								public
								classAppConfig {
								
									@Bean
								publicMyService myService() {
								return
								newMyServiceImpl(); } }

The AppConfigclass above would be equivalent to the following Spring <beans/>XML:

								<beans>
								<bean
								id=
								"myService"
								class=
								"com.acme.services.MyServiceImpl"
								/>
								</beans>

Full @Configuration vs 'lite' @Beans mode?

When @Beanmethods are declared within classes that are notannotated with @Configurationthey are referred to as being processed in a 'lite' mode. For example, bean methods declared in a @Componentor even in a plain old classwill be considered 'lite'.

Unlike full @Configuration, lite @Beanmethods cannot easily declare inter-bean dependencies. Usually one @Beanmethod should not invoke another @Beanmethod when operating in 'lite' mode.

Only using @Beanmethods within @Configurationclasses is a recommended approach of ensuring that 'full' mode is always used. This will prevent the same @Beanmethod from accidentally being invoked multiple times and helps to reduce subtle bugs that can be hard to track down when operating in 'lite' mode.

The @Beanand @Configurationannotations will be discussed in depth in the sections below. First, however, we’ll cover the various ways of creating a spring container using Java-based configuration.

7.12.2 Instantiating the Spring container using AnnotationConfigApplicationContext

The sections below document Spring’s AnnotationConfigApplicationContext, new in Spring 3.0. This versatile ApplicationContextimplementation is capable of accepting not only @Configurationclasses as input, but also plain @Componentclasses and classes annotated with JSR-330 metadata.

When @Configurationclasses are provided as input, the @Configurationclass itself is registered as a bean definition, and all declared @Beanmethods within the class are also registered as bean definitions.

When @Componentand JSR-330 classes are provided, they are registered as bean definitions, and it is assumed that DI metadata such as @Autowiredor @Injectare used within those classes where necessary.

Simple construction

In much the same way that Spring XML files are used as input when instantiating a ClassPathXmlApplicationContext, @Configurationclasses may be used as input when instantiating an AnnotationConfigApplicationContext. This allows for completely XML-free usage of the Spring container:

									public
									static
									voidmain(String[] args) { ApplicationContext ctx =
									newAnnotationConfigApplicationContext(AppConfig.
									class); MyService myService = ctx.getBean(MyService.
									class); myService.doStuff(); }

As mentioned above, AnnotationConfigApplicationContextis not limited to working only with @Configurationclasses. Any @Componentor JSR-330 annotated class may be supplied as input to the constructor. For example:

									public
									static
									voidmain(String[] args) { ApplicationContext ctx =
									newAnnotationConfigApplicationContext(MyServiceImpl.
									class, Dependency1.
									class, Dependency2.
									class); MyService myService = ctx.getBean(MyService.
									class); myService.doStuff(); }

The above assumes that MyServiceImpl, Dependency1and Dependency2use Spring dependency injection annotations such as @Autowired.

Building the container programmatically using register(Class<?>…​)

An AnnotationConfigApplicationContextmay be instantiated using a no-arg constructor and then configured using the register()method. This approach is particularly useful when programmatically building an AnnotationConfigApplicationContext.

									public
									static
									voidmain(String[] args) { AnnotationConfigApplicationContext ctx =
									newAnnotationConfigApplicationContext(); ctx.register(AppConfig.
									class, OtherConfig.
									class); ctx.register(AdditionalConfig.
									class); ctx.refresh(); MyService myService = ctx.getBean(MyService.
									class); myService.doStuff(); }

Enabling component scanning with scan(String…​)

To enable component scanning, just annotate your @Configurationclass as follows:

									
										@Configuration
									
										@ComponentScan(basePackages = "com.acme")
									public
									classAppConfig { ... }
[Tip] Tip

Experienced Spring users will be familiar with the XML declaration equivalent from Spring’s context:namespace

													<beans>
													<context:component-scan
													base-package=
													"com.acme"
													/>
													</beans>

In the example above, the com.acmepackage will be scanned, looking for any @Component-annotated classes, and those classes will be registered as Spring bean definitions within the container. AnnotationConfigApplicationContextexposes the scan(String…​)method to allow for the same component-scanning functionality:

									public
									static
									voidmain(String[] args) { AnnotationConfigApplicationContext ctx =
									newAnnotationConfigApplicationContext(); ctx.scan(
									"com.acme"); ctx.refresh(); MyService myService = ctx.getBean(MyService.
									class); }
[Note] Note

Remember that @Configurationclasses are meta-annotatedwith @Component, so they are candidates for component-scanning! In the example above, assuming that AppConfigis declared within the com.acmepackage (or any package underneath), it will be picked up during the call to scan(), and upon refresh()all its @Beanmethods will be processed and registered as bean definitions within the container.

Support for web applications with AnnotationConfigWebApplicationContext

A WebApplicationContextvariant of AnnotationConfigApplicationContextis available with AnnotationConfigWebApplicationContext. This implementation may be used when configuring the Spring ContextLoaderListenerservlet listener, Spring MVC DispatcherServlet, etc. What follows is a web.xmlsnippet that configures a typical Spring MVC web application. Note the use of the contextClasscontext-param and init-param:

									<web-app>
									<!-- Configure ContextLoaderListener to use AnnotationConfigWebApplicationContext instead of the default XmlWebApplicationContext -->
									<context-param>
									<param-name>contextClass
									</param-name>
									<param-value>org.springframework.web.context.support.AnnotationConfigWebApplicationContext
									</param-value>
									</context-param>
									<!-- Configuration locations must consist of one or more comma- or space-delimited fully-qualified @Configuration classes. Fully-qualified packages may also be specified for component-scanning -->
									<context-param>
									<param-name>contextConfigLocation
									</param-name>
									<param-value>com.acme.AppConfig
									</param-value>
									</context-param>
									<!-- Bootstrap the root application context as usual using ContextLoaderListener -->
									<listener>
									<listener-class>org.springframework.web.context.ContextLoaderListener
									</listener-class>
									</listener>
									<!-- Declare a Spring MVC DispatcherServlet as usual -->
									<servlet>
									<servlet-name>dispatcher
									</servlet-name>
									<servlet-class>org.springframework.web.servlet.DispatcherServlet
									</servlet-class>
									<!-- Configure DispatcherServlet to use AnnotationConfigWebApplicationContext instead of the default XmlWebApplicationContext -->
									<init-param>
									<param-name>contextClass
									</param-name>
									<param-value>org.springframework.web.context.support.AnnotationConfigWebApplicationContext
									</param-value>
									</init-param>
									<!-- Again, config locations must consist of one or more comma- or space-delimited and fully-qualified @Configuration classes -->
									<init-param>
									<param-name>contextConfigLocation
									</param-name>
									<param-value>com.acme.web.MvcConfig
									</param-value>
									</init-param>
									</servlet>
									<!-- map all requests for /app/* to the dispatcher servlet -->
									<servlet-mapping>
									<servlet-name>dispatcher
									</servlet-name>
									<url-pattern>/app/*
									</url-pattern>
									</servlet-mapping>
									</web-app>

7.12.3 Using the @Bean annotation

@Beanis a method-level annotation and a direct analog of the XML <bean/>element. The annotation supports some of the attributes offered by <bean/>, such as: init-method, destroy-method, autowiringand name.

You can use the @Beanannotation in a @Configuration-annotated or in a @Component-annotated class.

Declaring a bean

To declare a bean, simply annotate a method with the @Beanannotation. You use this method to register a bean definition within an ApplicationContextof the type specified as the method’s return value. By default, the bean name will be the same as the method name. The following is a simple example of a @Beanmethod declaration:

									
										@Configuration
									public
									classAppConfig {
									
										@Bean
									publicTransferService transferService() {
									return
									newTransferServiceImpl(); } }

The preceding configuration is exactly equivalent to the following Spring XML:

									<beans>
									<bean
									id=
									"transferService"
									class=
									"com.acme.TransferServiceImpl"
									/>
									</beans>

Both declarations make a bean named transferServiceavailable in the ApplicationContext, bound to an object instance of type TransferServiceImpl:

transferService -> com.acme.TransferServiceImpl

Bean dependencies

A @Beanannotated method can have an arbitrary number of parameters describing the dependencies required to build that bean. For instance if our TransferServicerequires an AccountRepositorywe can materialize that dependency via a method parameter:

									
										@Configuration
									public
									classAppConfig {
									
										@Bean
									publicTransferService transferService(AccountRepository accountRepository) {
									return
									newTransferServiceImpl(accountRepository); } }

The resolution mechanism is pretty much identical to constructor-based dependency injection, see the relevant sectionfor more details.

Receiving lifecycle callbacks

Any classes defined with the @Beanannotation support the regular lifecycle callbacks and can use the @PostConstructand @PreDestroyannotations from JSR-250, see JSR-250 annotationsfor further details.

The regular Spring lifecyclecallbacks are fully supported as well. If a bean implements InitializingBean, DisposableBean, or Lifecycle, their respective methods are called by the container.

The standard set of *Awareinterfaces such as BeanFactoryAware, BeanNameAware, MessageSourceAware, ApplicationContextAware, and so on are also fully supported.

The @Beanannotation supports specifying arbitrary initialization and destruction callback methods, much like Spring XML’s init-methodand destroy-methodattributes on the beanelement:

									public
									classFoo {
									public
									voidinit() {
									// initialization logic} }
									public
									classBar {
									public
									voidcleanup() {
									// destruction logic} }
									
										@Configuration
									public
									classAppConfig {
									
										@Bean(initMethod = "init")
									publicFoo foo() {
									return
									newFoo(); }
									
										@Bean(destroyMethod = "cleanup")
									publicBar bar() {
									return
									newBar(); } }
[Note] Note

By default, beans defined using Java config that have a public closeor shutdownmethod are automatically enlisted with a destruction callback. If you have a public closeor shutdownmethod and you do not wish for it to be called when the container shuts down, simply add @Bean(destroyMethod="")to your bean definition to disable the default (inferred)mode.

You may want to do that by default for a resource that you acquire via JNDI as its lifecycle is managed outside the application. In particular, make sure to always do it for a DataSourceas it is known to be problematic on Java EE application servers.

													
														@Bean(destroyMethod="")
													publicDataSource dataSource()
													throwsNamingException {
													return(DataSource) jndiTemplate.lookup(
													"MyDS"); }

Also, with @Beanmethods, you will typically choose to use programmatic JNDI lookups: either using Spring’s JndiTemplate/ JndiLocatorDelegatehelpers or straight JNDI InitialContextusage, but not the JndiObjectFactoryBeanvariant which would force you to declare the return type as the FactoryBeantype instead of the actual target type, making it harder to use for cross-reference calls in other @Beanmethods that intend to refer to the provided resource here.

Of course, in the case of Fooabove, it would be equally as valid to call the init()method directly during construction:

									
										@Configuration
									public
									classAppConfig {
									
										@Bean
									publicFoo foo() { Foo foo =
									newFoo(); foo.init();
									returnfoo; }
									// ...}
[Tip] Tip

When you work directly in Java, you can do anything you like with your objects and do not always need to rely on the container lifecycle!

Specifying bean scope

Using the @Scope annotation

You can specify that your beans defined with the @Beanannotation should have a specific scope. You can use any of the standard scopes specified in the Bean Scopessection.

The default scope is singleton, but you can override this with the @Scopeannotation:

										
											@Configuration
										public
										classMyConfiguration {
										
											@Bean
										
											@Scope("prototype")
										publicEncryptor encryptor() {
										// ...} }
@Scope and scoped-proxy

Spring offers a convenient way of working with scoped dependencies through scoped proxies. The easiest way to create such a proxy when using the XML configuration is the <aop:scoped-proxy/>element. Configuring your beans in Java with a @Scope annotation offers equivalent support with the proxyMode attribute. The default is no proxy ( ScopedProxyMode.NO), but you can specify ScopedProxyMode.TARGET_CLASSor ScopedProxyMode.INTERFACES.

If you port the scoped proxy example from the XML reference documentation (see preceding link) to our @Beanusing Java, it would look like the following:

										// an HTTP Session-scoped bean exposed as a proxy
										
											@Bean
										
											@SessionScope
										publicUserPreferences userPreferences() {
										return
										newUserPreferences(); }
										
											@Bean
										publicService userService() { UserService service =
										newSimpleUserService();
										// a reference to the proxied userPreferences beanservice.setUserPreferences(userPreferences());
										returnservice; }

Customizing bean naming

By default, configuration classes use a @Beanmethod’s name as the name of the resulting bean. This functionality can be overridden, however, with the nameattribute.

									
										@Configuration
									public
									classAppConfig {
									
										@Bean(name = "myFoo")
									publicFoo foo() {
									return
									newFoo(); } }

Bean aliasing

As discussed in Section 7.3.1, “Naming beans”, it is sometimes desirable to give a single bean multiple names, otherwise known as bean aliasing. The nameattribute of the @Beanannotation accepts a String array for this purpose.

									
										@Configuration
									public
									classAppConfig {
									
										@Bean(name = { "dataSource", "subsystemA-dataSource", "subsystemB-dataSource" })
									publicDataSource dataSource() {
									// instantiate, configure and return DataSource bean...} }

Bean description

Sometimes it is helpful to provide a more detailed textual description of a bean. This can be particularly useful when beans are exposed (perhaps via JMX) for monitoring purposes.

To add a description to a @Beanthe @Descriptionannotation can be used:

									
										@Configuration
									public
									classAppConfig {
									
										@Bean
									
										@Description("Provides a basic example of a bean")
									publicFoo foo() {
									return
									newFoo(); } }

7.12.4 Using the @Configuration annotation

@Configurationis a class-level annotation indicating that an object is a source of bean definitions. @Configurationclasses declare beans via public @Beanannotated methods. Calls to @Beanmethods on @Configurationclasses can also be used to define inter-bean dependencies. See Section 7.12.1, “Basic concepts: @Bean and @Configuration”for a general introduction.

Injecting inter-bean dependencies

When @Beans have dependencies on one another, expressing that dependency is as simple as having one bean method call another:

									
										@Configuration
									public
									classAppConfig {
									
										@Bean
									publicFoo foo() {
									return
									newFoo(bar()); }
									
										@Bean
									publicBar bar() {
									return
									newBar(); } }

In the example above, the foobean receives a reference to barvia constructor injection.

[Note] Note

This method of declaring inter-bean dependencies only works when the @Beanmethod is declared within a @Configurationclass. You cannot declare inter-bean dependencies using plain @Componentclasses.

Lookup method injection

As noted earlier, lookup method injectionis an advanced feature that you should use rarely. It is useful in cases where a singleton-scoped bean has a dependency on a prototype-scoped bean. Using Java for this type of configuration provides a natural means for implementing this pattern.

									public
									abstract
									classCommandManager {
									publicObject process(Object commandState) {
									// grab a new instance of the appropriate Command interfaceCommand command = createCommand();
									// set the state on the (hopefully brand new) Command instancecommand.setState(commandState);
									returncommand.execute(); }
									// okay... but where is the implementation of this method?
									protected
									abstractCommand createCommand(); }

Using Java-configuration support , you can create a subclass of CommandManagerwhere the abstract createCommand()method is overridden in such a way that it looks up a new (prototype) command object:

									
										@Bean
									
										@Scope("prototype")
									publicAsyncCommand asyncCommand() { AsyncCommand command =
									newAsyncCommand();
									// inject dependencies here as required
									returncommand; }
									
										@Bean
									publicCommandManager commandManager() {
									// return new anonymous implementation of CommandManager with command() overridden
									// to return a new prototype Command object
									return
									newCommandManager() {
									protectedCommand createCommand() {
									returnasyncCommand(); } } }

Further information about how Java-based configuration works internally

The following example shows a @Beanannotated method being called twice:

									
										@Configuration
									public
									classAppConfig {
									
										@Bean
									publicClientService clientService1() { ClientServiceImpl clientService =
									newClientServiceImpl(); clientService.setClientDao(clientDao());
									returnclientService; }
									
										@Bean
									publicClientService clientService2() { ClientServiceImpl clientService =
									newClientServiceImpl(); clientService.setClientDao(clientDao());
									returnclientService; }
									
										@Bean
									publicClientDao clientDao() {
									return
									newClientDaoImpl(); } }

clientDao()has been called once in clientService1()and once in clientService2(). Since this method creates a new instance of ClientDaoImpland returns it, you would normally expect having 2 instances (one for each service). That definitely would be problematic: in Spring, instantiated beans have a singletonscope by default. This is where the magic comes in: All @Configurationclasses are subclassed at startup-time with CGLIB. In the subclass, the child method checks the container first for any cached (scoped) beans before it calls the parent method and creates a new instance. Note that as of Spring 3.2, it is no longer necessary to add CGLIB to your classpath because CGLIB classes have been repackaged under org.springframework.cgliband included directly within the spring-core JAR.

[Note] Note

The behavior could be different according to the scope of your bean. We are talking about singletons here.
[Tip] Tip

There are a few restrictions due to the fact that CGLIB dynamically adds features at startup-time, in particular that configuration classes must not be final. However, as of 4.3, any constructors are allowed on configuration classes, including the use of @Autowiredor a single non-default constructor declaration for default injection.

If you prefer to avoid any CGLIB-imposed limitations, consider declaring your @Beanmethods on non- @Configurationclasses, e.g. on plain @Componentclasses instead. Cross-method calls between @Beanmethods won’t get intercepted then, so you’ll have to exclusively rely on dependency injection at the constructor or method level there.

7.12.5 Composing Java-based configurations

Using the @Import annotation

Much as the <import/>element is used within Spring XML files to aid in modularizing configurations, the @Importannotation allows for loading @Beandefinitions from another configuration class:

									
										@Configuration
									public
									classConfigA {
									
										@Bean
									publicA a() {
									return
									newA(); } }
									
										@Configuration
									
										@Import(ConfigA.class)
									public
									classConfigB {
									
										@Bean
									publicB b() {
									return
									newB(); } }

Now, rather than needing to specify both ConfigA.classand ConfigB.classwhen instantiating the context, only ConfigBneeds to be supplied explicitly:

									public
									static
									voidmain(String[] args) { ApplicationContext ctx =
									newAnnotationConfigApplicationContext(ConfigB.
									class);
									// now both beans A and B will be available...A a = ctx.getBean(A.
									class); B b = ctx.getBean(B.
									class); }

This approach simplifies container instantiation, as only one class needs to be dealt with, rather than requiring the developer to remember a potentially large number of @Configurationclasses during construction.

[Tip] Tip

As of Spring Framework 4.2, @Importalso supports references to regular component classes, analogous to the AnnotationConfigApplicationContext.registermethod. This is particularly useful if you’d like to avoid component scanning, using a few configuration classes as entry points for explicitly defining all your components.
Injecting dependencies on imported @Bean definitions

The example above works, but is simplistic. In most practical scenarios, beans will have dependencies on one another across configuration classes. When using XML, this is not an issue, per se, because there is no compiler involved, and one can simply declare ref="someBean"and trust that Spring will work it out during container initialization. Of course, when using @Configurationclasses, the Java compiler places constraints on the configuration model, in that references to other beans must be valid Java syntax.

Fortunately, solving this problem is simple. As we already discussed, @Beanmethod can have an arbitrary number of parameters describing the bean dependencies. Let’s consider a more real-world scenario with several @Configurationclasses, each depending on beans declared in the others:

										
											@Configuration
										public
										classServiceConfig {
										
											@Bean
										publicTransferService transferService(AccountRepository accountRepository) {
										return
										newTransferServiceImpl(accountRepository); } }
										
											@Configuration
										public
										classRepositoryConfig {
										
											@Bean
										publicAccountRepository accountRepository(DataSource dataSource) {
										return
										newJdbcAccountRepository(dataSource); } }
										
											@Configuration
										
											@Import({ServiceConfig.class, RepositoryConfig.class})
										public
										classSystemTestConfig {
										
											@Bean
										publicDataSource dataSource() {
										// return new DataSource} }
										public
										static
										voidmain(String[] args) { ApplicationContext ctx =
										newAnnotationConfigApplicationContext(SystemTestConfig.
										class);
										// everything wires up across configuration classes...TransferService transferService = ctx.getBean(TransferService.
										class); transferService.transfer(
										100.00,
										"A123",
										"C456"); }

There is another way to achieve the same result. Remember that @Configurationclasses are ultimately just another bean in the container: This means that they can take advantage of @Autowiredand @Valueinjection etc just like any other bean!

[Warning] Warning

Make sure that the dependencies you inject that way are of the simplest kind only. @Configurationclasses are processed quite early during the initialization of the context and forcing a dependency to be injected this way may lead to unexpected early initialization. Whenever possible, resort to parameter-based injection as in the example above.

Also, be particularly careful with BeanPostProcessorand BeanFactoryPostProcessordefinitions via @Bean. Those should usually be declared as static @Beanmethods, not triggering the instantiation of their containing configuration class. Otherwise, @Autowiredand @Valuewon’t work on the configuration class itself since it is being created as a bean instance too early.

 
										
											@Configuration
										public
										classServiceConfig {
										
											@Autowired
										privateAccountRepository accountRepository;
										
											@Bean
										publicTransferService transferService() {
										return
										newTransferServiceImpl(accountRepository); } }
										
											@Configuration
										public
										classRepositoryConfig {
										private
										finalDataSource dataSource;
										
											@Autowired
										publicRepositoryConfig(DataSource dataSource) {
										this.dataSource = dataSource; }
										
											@Bean
										publicAccountRepository accountRepository() {
										return
										newJdbcAccountRepository(dataSource); } }
										
											@Configuration
										
											@Import({ServiceConfig.class, RepositoryConfig.class})
										public
										classSystemTestConfig {
										
											@Bean
										publicDataSource dataSource() {
										// return new DataSource} }
										public
										static
										voidmain(String[] args) { ApplicationContext ctx =
										newAnnotationConfigApplicationContext(SystemTestConfig.
										class);
										// everything wires up across configuration classes...TransferService transferService = ctx.getBean(TransferService.
										class); transferService.transfer(
										100.00,
										"A123",
										"C456"); }
[Tip] Tip

Constructor injection in @Configurationclasses is only supported as of Spring Framework 4.3. Note also that there is no need to specify @Autowiredif the target bean defines only one constructor; in the example above, @Autowiredis not necessary on the RepositoryConfigconstructor.

In the scenario above, using @Autowiredworks well and provides the desired modularity, but determining exactly where the autowired bean definitions are declared is still somewhat ambiguous. For example, as a developer looking at ServiceConfig, how do you know exactly where the @Autowired AccountRepositorybean is declared? It’s not explicit in the code, and this may be just fine. Remember that the Spring Tool Suiteprovides tooling that can render graphs showing how everything is wired up - that may be all you need. Also, your Java IDE can easily find all declarations and uses of the AccountRepositorytype, and will quickly show you the location of @Beanmethods that return that type.

In cases where this ambiguity is not acceptable and you wish to have direct navigation from within your IDE from one @Configurationclass to another, consider autowiring the configuration classes themselves:

										
											@Configuration
										public
										classServiceConfig {
										
											@Autowired
										privateRepositoryConfig repositoryConfig;
										
											@Bean
										publicTransferService transferService() {
										// navigate 'through' the config class to the @Bean method!
										return
										newTransferServiceImpl(repositoryConfig.accountRepository()); } }

In the situation above, it is completely explicit where AccountRepositoryis defined. However, ServiceConfigis now tightly coupled to RepositoryConfig; that’s the tradeoff. This tight coupling can be somewhat mitigated by using interface-based or abstract class-based @Configurationclasses. Consider the following:

										
											@Configuration
										public
										classServiceConfig {
										
											@Autowired
										privateRepositoryConfig repositoryConfig;
										
											@Bean
										publicTransferService transferService() {
										return
										newTransferServiceImpl(repositoryConfig.accountRepository()); } }
										
											@Configuration
										public
										interfaceRepositoryConfig {
										
											@BeanAccountRepository accountRepository(); }
										
											@Configuration
										public
										classDefaultRepositoryConfig
										implementsRepositoryConfig {
										
											@Bean
										publicAccountRepository accountRepository() {
										return
										newJdbcAccountRepository(...); } }
										
											@Configuration
										
											@Import({ServiceConfig.class, DefaultRepositoryConfig.class})
										// import the concrete config!
										public
										classSystemTestConfig {
										
											@Bean
										publicDataSource dataSource() {
										// return DataSource} }
										public
										static
										voidmain(String[] args) { ApplicationContext ctx =
										newAnnotationConfigApplicationContext(SystemTestConfig.
										class); TransferService transferService = ctx.getBean(TransferService.
										class); transferService.transfer(
										100.00,
										"A123",
										"C456"); }

Now ServiceConfigis loosely coupled with respect to the concrete DefaultRepositoryConfig, and built-in IDE tooling is still useful: it will be easy for the developer to get a type hierarchy of RepositoryConfigimplementations. In this way, navigating @Configurationclasses and their dependencies becomes no different than the usual process of navigating interface-based code.

Conditionally include @Configuration classes or @Bean methods

It is often useful to conditionally enable or disable a complete @Configurationclass, or even individual @Beanmethods, based on some arbitrary system state. One common example of this is to use the @Profileannotation to activate beans only when a specific profile has been enabled in the Spring Environment(see Section 7.13.1, “Bean definition profiles”for details).

The @Profileannotation is actually implemented using a much more flexible annotation called @Conditional. The @Conditionalannotation indicates specific org.springframework.context.annotation.Conditionimplementations that should be consulted before a @Beanis registered.

Implementations of the Conditioninterface simply provide a matches(…​)method that returns trueor false. For example, here is the actual Conditionimplementation used for @Profile:

									
										@Override
									public
									booleanmatches(ConditionContext context, AnnotatedTypeMetadata metadata) {
									if(context.getEnvironment() != null) {
									// Read the @Profile annotation attributesMultiValueMap<String, Object> attrs = metadata.getAllAnnotationAttributes(Profile.
									class.getName());
									if(attrs != null) {
									for(Object value : attrs.get(
									"value")) {
									if(context.getEnvironment().acceptsProfiles(((String[]) value))) {
									returntrue; } }
									returnfalse; } }
									returntrue; }

See the @Conditionaljavadocsfor more detail.

Combining Java and XML configuration

Spring’s @Configurationclass support does not aim to be a 100% complete replacement for Spring XML. Some facilities such as Spring XML namespaces remain an ideal way to configure the container. In cases where XML is convenient or necessary, you have a choice: either instantiate the container in an "XML-centric" way using, for example, ClassPathXmlApplicationContext, or in a "Java-centric" fashion using AnnotationConfigApplicationContextand the @ImportResourceannotation to import XML as needed.

XML-centric use of @Configuration classes

It may be preferable to bootstrap the Spring container from XML and include @Configurationclasses in an ad-hoc fashion. For example, in a large existing codebase that uses Spring XML, it will be easier to create @Configurationclasses on an as-needed basis and include them from the existing XML files. Below you’ll find the options for using @Configurationclasses in this kind of "XML-centric" situation.

Remember that @Configurationclasses are ultimately just bean definitions in the container. In this example, we create a @Configurationclass named AppConfigand include it within system-test-config.xmlas a <bean/>definition. Because <context:annotation-config/>is switched on, the container will recognize the @Configurationannotation and process the @Beanmethods declared in AppConfigproperly.

										
											@Configuration
										public
										classAppConfig {
										
											@Autowired
										privateDataSource dataSource;
										
											@Bean
										publicAccountRepository accountRepository() {
										return
										newJdbcAccountRepository(dataSource); }
										
											@Bean
										publicTransferService transferService() {
										return
										newTransferService(accountRepository()); } }

system-test-config.xml:

										<beans>
										<!-- enable processing of annotations such as @Autowired and @Configuration -->
										<context:annotation-config/>
										<context:property-placeholder
										location=
										"classpath:/com/acme/jdbc.properties"
										/>
										<bean
										class=
										"com.acme.AppConfig"
										/>
										<bean
										class=
										"org.springframework.jdbc.datasource.DriverManagerDataSource"
										>
										<property
										name=
										"url"
										value=
										"${jdbc.url}"
										/>
										<property
										name=
										"username"
										value=
										"${jdbc.username}"
										/>
										<property
										name=
										"password"
										value=
										"${jdbc.password}"
										/>
										</bean>
										</beans>

jdbc.properties:

jdbc.url=jdbc:hsqldb:hsql://localhost/xdb jdbc.username=sa jdbc.password=
										public
										static
										voidmain(String[] args) { ApplicationContext ctx =
										newClassPathXmlApplicationContext(
										"classpath:/com/acme/system-test-config.xml"); TransferService transferService = ctx.getBean(TransferService.
										class);
										// ...}
[Note] Note

In system-test-config.xmlabove, the AppConfig <bean/>does not declare an idelement. While it would be acceptable to do so, it is unnecessary given that no other bean will ever refer to it, and it is unlikely that it will be explicitly fetched from the container by name. Likewise with the DataSourcebean - it is only ever autowired by type, so an explicit bean idis not strictly required.

Because @Configurationis meta-annotated with @Component, @Configuration-annotated classes are automatically candidates for component scanning. Using the same scenario as above, we can redefine system-test-config.xmlto take advantage of component-scanning. Note that in this case, we don’t need to explicitly declare <context:annotation-config/>, because <context:component-scan/>enables the same functionality.

system-test-config.xml:

										<beans>
										<!-- picks up and registers AppConfig as a bean definition -->
										<context:component-scan
										base-package=
										"com.acme"
										/>
										<context:property-placeholder
										location=
										"classpath:/com/acme/jdbc.properties"
										/>
										<bean
										class=
										"org.springframework.jdbc.datasource.DriverManagerDataSource"
										>
										<property
										name=
										"url"
										value=
										"${jdbc.url}"
										/>
										<property
										name=
										"username"
										value=
										"${jdbc.username}"
										/>
										<property
										name=
										"password"
										value=
										"${jdbc.password}"
										/>
										</bean>
										</beans>
@Configuration class-centric use of XML with @ImportResource

In applications where @Configurationclasses are the primary mechanism for configuring the container, it will still likely be necessary to use at least some XML. In these scenarios, simply use @ImportResourceand define only as much XML as is needed. Doing so achieves a "Java-centric" approach to configuring the container and keeps XML to a bare minimum.

										
											@Configuration
										
											@ImportResource("classpath:/com/acme/properties-config.xml")
										public
										classAppConfig {
										
											@Value("${jdbc.url}")
										privateString url;
										
											@Value("${jdbc.username}")
										privateString username;
										
											@Value("${jdbc.password}")
										privateString password;
										
											@Bean
										publicDataSource dataSource() {
										return
										newDriverManagerDataSource(url, username, password); } }
properties-config.xml
										<beans>
										<context:property-placeholder
										location=
										"classpath:/com/acme/jdbc.properties"
										/>
										</beans>
jdbc.properties jdbc.url=jdbc:hsqldb:hsql://localhost/xdb jdbc.username=sa jdbc.password=
										public
										static
										voidmain(String[] args) { ApplicationContext ctx =
										newAnnotationConfigApplicationContext(AppConfig.
										class); TransferService transferService = ctx.getBean(TransferService.
										class);
										// ...}

7.13 Environment abstraction

The Environmentis an abstraction integrated in the container that models two key aspects of the application environment: profiles and properties .

A profileis a named, logical group of bean definitions to be registered with the container only if the given profile is active. Beans may be assigned to a profile whether defined in XML or via annotations. The role of the Environmentobject with relation to profiles is in determining which profiles (if any) are currently active, and which profiles (if any) should be active by default.

Properties play an important role in almost all applications, and may originate from a variety of sources: properties files, JVM system properties, system environment variables, JNDI, servlet context parameters, ad-hoc Properties objects, Maps, and so on. The role of the Environmentobject with relation to properties is to provide the user with a convenient service interface for configuring property sources and resolving properties from them.

7.13.1 Bean definition profiles

Bean definition profiles is a mechanism in the core container that allows for registration of different beans in different environments. The word environmentcan mean different things to different users and this feature can help with many use cases, including:

  • working against an in-memory datasource in development vs looking up that same datasource from JNDI when in QA or production
  • registering monitoring infrastructure only when deploying an application into a performance environment
  • registering customized implementations of beans for customer A vs. customer B deployments

Let’s consider the first use case in a practical application that requires a DataSource. In a test environment, the configuration may look like this:

								
									@Bean
								publicDataSource dataSource() {
								return
								newEmbeddedDatabaseBuilder() .setType(EmbeddedDatabaseType.HSQL) .addScript(
								"my-schema.sql") .addScript(
								"my-test-data.sql") .build(); }

Let’s now consider how this application will be deployed into a QA or production environment, assuming that the datasource for the application will be registered with the production application server’s JNDI directory. Our dataSourcebean now looks like this:

								
									@Bean(destroyMethod="")
								publicDataSource dataSource()
								throwsException { Context ctx =
								newInitialContext();
								return(DataSource) ctx.lookup(
								"java:comp/env/jdbc/datasource"); }

The problem is how to switch between using these two variations based on the current environment. Over time, Spring users have devised a number of ways to get this done, usually relying on a combination of system environment variables and XML <import/>statements containing ${placeholder}tokens that resolve to the correct configuration file path depending on the value of an environment variable. Bean definition profiles is a core container feature that provides a solution to this problem.

If we generalize the example use case above of environment-specific bean definitions, we end up with the need to register certain bean definitions in certain contexts, while not in others. You could say that you want to register a certain profile of bean definitions in situation A, and a different profile in situation B. Let’s first see how we can update our configuration to reflect this need.

@Profile

The @Profileannotation allows you to indicate that a component is eligible for registration when one or more specified profiles are active. Using our example above, we can rewrite the dataSourceconfiguration as follows:

									
										@Configuration
									
										@Profile("dev")
									public
									classStandaloneDataConfig {
									
										@Bean
									publicDataSource dataSource() {
									return
									newEmbeddedDatabaseBuilder() .setType(EmbeddedDatabaseType.HSQL) .addScript(
									"classpath:com/bank/config/sql/schema.sql") .addScript(
									"classpath:com/bank/config/sql/test-data.sql") .build(); } }
									
										@Configuration
									
										@Profile("production")
									public
									classJndiDataConfig {
									
										@Bean(destroyMethod="")
									publicDataSource dataSource()
									throwsException { Context ctx =
									newInitialContext();
									return(DataSource) ctx.lookup(
									"java:comp/env/jdbc/datasource"); } }
[Note] Note

As mentioned before, with @Beanmethods, you will typically choose to use programmatic JNDI lookups: either using Spring’s JndiTemplate/ JndiLocatorDelegatehelpers or the straight JNDI InitialContextusage shown above, but not the JndiObjectFactoryBeanvariant which would force you to declare the return type as the FactoryBeantype.

@Profilecan be used as a meta-annotationfor the purpose of creating a custom composed annotation. The following example defines a custom @Productionannotation that can be used as a drop-in replacement for @Profile("production"):

									
										@Target(ElementType.TYPE)
									
										@Retention(RetentionPolicy.RUNTIME)
									
										@Profile("production")
									public
									
										@interfaceProduction { }

@Profilecan also be declared at the method level to include only one particular bean of a configuration class:

									
										@Configuration
									public
									classAppConfig {
									
										@Bean
									
										@Profile("dev")
									publicDataSource devDataSource() {
									return
									newEmbeddedDatabaseBuilder() .setType(EmbeddedDatabaseType.HSQL) .addScript(
									"classpath:com/bank/config/sql/schema.sql") .addScript(
									"classpath:com/bank/config/sql/test-data.sql") .build(); }
									
										@Bean
									
										@Profile("production")
									publicDataSource productionDataSource()
									throwsException { Context ctx =
									newInitialContext();
									return(DataSource) ctx.lookup(
									"java:comp/env/jdbc/datasource"); } }
[Tip] Tip

If a @Configurationclass is marked with @Profile, all of the @Beanmethods and @Importannotations associated with that class will be bypassed unless one or more of the specified profiles are active. If a @Componentor @Configurationclass is marked with @Profile({"p1", "p2"}), that class will not be registered/processed unless profiles 'p1' and/or 'p2' have been activated. If a given profile is prefixed with the NOT operator ( !), the annotated element will be registered if the profile is notactive. For example, given @Profile({"p1", "!p2"}), registration will occur if profile 'p1' is active or if profile 'p2' is not active.

7.13.2 XML bean definition profiles

The XML counterpart is the profileattribute of the <beans>element. Our sample configuration above can be rewritten in two XML files as follows:

								<beans
								profile=
								"dev"
								xmlns=
								"http://www.springframework.org/schema/beans"
								xmlns:xsi=
								"http://www.w3.org/2001/XMLSchema-instance"
								xmlns:jdbc=
								"http://www.springframework.org/schema/jdbc"
								xsi:schemaLocation=
								"..."
								>
								<jdbc:embedded-database
								id=
								"dataSource"
								>
								<jdbc:script
								location=
								"classpath:com/bank/config/sql/schema.sql"
								/>
								<jdbc:script
								location=
								"classpath:com/bank/config/sql/test-data.sql"
								/>
								</jdbc:embedded-database>
								</beans>
								<beans
								profile=
								"production"
								xmlns=
								"http://www.springframework.org/schema/beans"
								xmlns:xsi=
								"http://www.w3.org/2001/XMLSchema-instance"
								xmlns:jee=
								"http://www.springframework.org/schema/jee"
								xsi:schemaLocation=
								"..."
								>
								<jee:jndi-lookup
								id=
								"dataSource"
								jndi-name=
								"java:comp/env/jdbc/datasource"
								/>
								</beans>

It is also possible to avoid that split and nest <beans/>elements within the same file:

								<beans
								xmlns=
								"http://www.springframework.org/schema/beans"
								xmlns:xsi=
								"http://www.w3.org/2001/XMLSchema-instance"
								xmlns:jdbc=
								"http://www.springframework.org/schema/jdbc"
								xmlns:jee=
								"http://www.springframework.org/schema/jee"
								xsi:schemaLocation=
								"..."
								>
								<!-- other bean definitions -->
								<beans
								profile=
								"dev"
								>
								<jdbc:embedded-database
								id=
								"dataSource"
								>
								<jdbc:script
								location=
								"classpath:com/bank/config/sql/schema.sql"
								/>
								<jdbc:script
								location=
								"classpath:com/bank/config/sql/test-data.sql"
								/>
								</jdbc:embedded-database>
								</beans>
								<beans
								profile=
								"production"
								>
								<jee:jndi-lookup
								id=
								"dataSource"
								jndi-name=
								"java:comp/env/jdbc/datasource"
								/>
								</beans>
								</beans>

The spring-bean.xsdhas been constrained to allow such elements only as the last ones in the file. This should help provide flexibility without incurring clutter in the XML files.

Activating a profile

Now that we have updated our configuration, we still need to instruct Spring which profile is active. If we started our sample application right now, we would see a NoSuchBeanDefinitionExceptionthrown, because the container could not find the Spring bean named dataSource.

Activating a profile can be done in several ways, but the most straightforward is to do it programmatically against the EnvironmentAPI which is available via an ApplicationContext:

AnnotationConfigApplicationContext ctx =
									newAnnotationConfigApplicationContext(); ctx.getEnvironment().setActiveProfiles(
									"dev"); ctx.register(SomeConfig.
									class, StandaloneDataConfig.
									class, JndiDataConfig.
									class); ctx.refresh();

In addition, profiles may also be activated declaratively through the spring.profiles.activeproperty which may be specified through system environment variables, JVM system properties, servlet context parameters in web.xml, or even as an entry in JNDI (see Section 7.13.3, “PropertySource abstraction”). In integration tests, active profiles can be declared via the @ActiveProfilesannotation in the spring-testmodule (see the section called “Context configuration with environment profiles”).

Note that profiles are not an "either-or" proposition; it is possible to activate multiple profiles at once. Programmatically, simply provide multiple profile names to the setActiveProfiles()method, which accepts String…​varargs:

ctx.getEnvironment().setActiveProfiles(
									"profile1",
									"profile2");

Declaratively, spring.profiles.activemay accept a comma-separated list of profile names:

-Dspring.profiles.active=
									"profile1,profile2"

Default profile

The defaultprofile represents the profile that is enabled by default. Consider the following:

									
										@Configuration
									
										@Profile("default")
									public
									classDefaultDataConfig {
									
										@Bean
									publicDataSource dataSource() {
									return
									newEmbeddedDatabaseBuilder() .setType(EmbeddedDatabaseType.HSQL) .addScript(
									"classpath:com/bank/config/sql/schema.sql") .build(); } }

If no profile is active, the dataSourceabove will be created; this can be seen as a way to provide a defaultdefinition for one or more beans. If any profile is enabled, the defaultprofile will not apply.

The name of the default profile can be changed using setDefaultProfiles()on the Environmentor declaratively using the spring.profiles.defaultproperty.

7.13.3 PropertySource abstraction

Spring’s Environmentabstraction provides search operations over a configurable hierarchy of property sources. To explain fully, consider the following:

ApplicationContext ctx =
								newGenericApplicationContext(); Environment env = ctx.getEnvironment();
								booleancontainsFoo = env.containsProperty(
								"foo"); System.out.println(
								"Does my environment contain the 'foo' property? "+ containsFoo);

In the snippet above, we see a high-level way of asking Spring whether the fooproperty is defined for the current environment. To answer this question, the Environmentobject performs a search over a set of PropertySourceobjects. A PropertySourceis a simple abstraction over any source of key-value pairs, and Spring’s StandardEnvironmentis configured with two PropertySource objects — one representing the set of JVM system properties ( a la System.getProperties()) and one representing the set of system environment variables ( a la System.getenv()).

[Note] Note

These default property sources are present for StandardEnvironment, for use in standalone applications. StandardServletEnvironmentis populated with additional default property sources including servlet config and servlet context parameters. StandardPortletEnvironmentsimilarly has access to portlet config and portlet context parameters as property sources. Both can optionally enable a JndiPropertySource. See the javadocs for details.

Concretely, when using the StandardEnvironment, the call to env.containsProperty("foo")will return true if a foosystem property or fooenvironment variable is present at runtime.

[Tip] Tip

The search performed is hierarchical. By default, system properties have precedence over environment variables, so if the fooproperty happens to be set in both places during a call to env.getProperty("foo"), the system property value will 'win' and be returned preferentially over the environment variable. Note that property values will not get merged but rather completely overridden by a preceding entry.

For a common StandardServletEnvironment, the full hierarchy looks as follows, with the highest-precedence entries at the top:

  • ServletConfig parameters (if applicable, e.g. in case of a DispatcherServletcontext)
  • ServletContext parameters (web.xml context-param entries)
  • JNDI environment variables ("java:comp/env/" entries)
  • JVM system properties ("-D" command-line arguments)
  • JVM system environment (operating system environment variables)

Most importantly, the entire mechanism is configurable. Perhaps you have a custom source of properties that you’d like to integrate into this search. No problem — simply implement and instantiate your own PropertySourceand add it to the set of PropertySourcesfor the current Environment:

ConfigurableApplicationContext ctx =
								newGenericApplicationContext(); MutablePropertySources sources = ctx.getEnvironment().getPropertySources(); sources.addFirst(
								newMyPropertySource());

In the code above, MyPropertySourcehas been added with highest precedence in the search. If it contains a fooproperty, it will be detected and returned ahead of any fooproperty in any other PropertySource. The MutablePropertySourcesAPI exposes a number of methods that allow for precise manipulation of the set of property sources.

7.13.4 @PropertySource

The @PropertySourceannotation provides a convenient and declarative mechanism for adding a PropertySourceto Spring’s Environment.

Given a file "app.properties" containing the key/value pair testbean.name=myTestBean, the following @Configurationclass uses @PropertySourcein such a way that a call to testBean.getName()will return "myTestBean".

								
									@Configuration
								
									@PropertySource("classpath:/com/myco/app.properties")
								public
								classAppConfig {
								
									@AutowiredEnvironment env;
								
									@Bean
								publicTestBean testBean() { TestBean testBean =
								newTestBean(); testBean.setName(env.getProperty(
								"testbean.name"));
								returntestBean; } }

Any ${…​}placeholders present in a @PropertySourceresource location will be resolved against the set of property sources already registered against the environment. For example:

								
									@Configuration
								
									@PropertySource("classpath:/com/${my.placeholder:default/path}/app.properties")
								public
								classAppConfig {
								
									@AutowiredEnvironment env;
								
									@Bean
								publicTestBean testBean() { TestBean testBean =
								newTestBean(); testBean.setName(env.getProperty(
								"testbean.name"));
								returntestBean; } }

Assuming that "my.placeholder" is present in one of the property sources already registered, e.g. system properties or environment variables, the placeholder will be resolved to the corresponding value. If not, then "default/path" will be used as a default. If no default is specified and a property cannot be resolved, an IllegalArgumentExceptionwill be thrown.

7.13.5 Placeholder resolution in statements

Historically, the value of placeholders in elements could be resolved only against JVM system properties or environment variables. No longer is this the case. Because the Environment abstraction is integrated throughout the container, it’s easy to route resolution of placeholders through it. This means that you may configure the resolution process in any way you like: change the precedence of searching through system properties and environment variables, or remove them entirely; add your own property sources to the mix as appropriate.

Concretely, the following statement works regardless of where the customerproperty is defined, as long as it is available in the Environment:

								<beans>
								<import
								resource=
								"com/bank/service/${customer}-config.xml"
								/>
								</beans>

7.14 Registering a LoadTimeWeaver

The LoadTimeWeaveris used by Spring to dynamically transform classes as they are loaded into the Java virtual machine (JVM).

To enable load-time weaving add the @EnableLoadTimeWeavingto one of your @Configurationclasses:

							
								@Configuration
							
								@EnableLoadTimeWeaving
							public
							classAppConfig { }

Alternatively for XML configuration use the context:load-time-weaverelement:

							<beans>
							<context:load-time-weaver/>
							</beans>

Once configured for the ApplicationContext. Any bean within that ApplicationContextmay implement LoadTimeWeaverAware, thereby receiving a reference to the load-time weaver instance. This is particularly useful in combination with Spring’s JPA supportwhere load-time weaving may be necessary for JPA class transformation. Consult the LocalContainerEntityManagerFactoryBeanjavadocs for more detail. For more on AspectJ load-time weaving, see Section 11.8.4, “Load-time weaving with AspectJ in the Spring Framework”.

7.15 Additional Capabilities of the ApplicationContext

As was discussed in the chapter introduction, the org.springframework.beans.factorypackage provides basic functionality for managing and manipulating beans, including in a programmatic way. The org.springframework.contextpackage adds the ApplicationContextinterface, which extends the BeanFactoryinterface, in addition to extending other interfaces to provide additional functionality in a more application framework-oriented style. Many people use the ApplicationContextin a completely declarative fashion, not even creating it programmatically, but instead relying on support classes such as ContextLoaderto automatically instantiate an ApplicationContextas part of the normal startup process of a Java EE web application.

To enhance BeanFactoryfunctionality in a more framework-oriented style the context package also provides the following functionality:

  • Access to messages in i18n-style, through the MessageSourceinterface.
  • Access to resources, such as URLs and files, through the ResourceLoaderinterface.
  • Event publicationto namely beans implementing the ApplicationListenerinterface, through the use of the ApplicationEventPublisherinterface.
  • Loading of multiple (hierarchical) contexts, allowing each to be focused on one particular layer, such as the web layer of an application, through the HierarchicalBeanFactoryinterface.

7.15.1 Internationalization using MessageSource

The ApplicationContextinterface extends an interface called MessageSource, and therefore provides internationalization (i18n) functionality. Spring also provides the interface HierarchicalMessageSource, which can resolve messages hierarchically. Together these interfaces provide the foundation upon which Spring effects message resolution. The methods defined on these interfaces include:

  • String getMessage(String code, Object[] args, String default, Locale loc): The basic method used to retrieve a message from the MessageSource. When no message is found for the specified locale, the default message is used. Any arguments passed in become replacement values, using the MessageFormatfunctionality provided by the standard library.
  • String getMessage(String code, Object[] args, Locale loc): Essentially the same as the previous method, but with one difference: no default message can be specified; if the message cannot be found, a NoSuchMessageExceptionis thrown.
  • String getMessage(MessageSourceResolvable resolvable, Locale locale): All properties used in the preceding methods are also wrapped in a class named MessageSourceResolvable, which you can use with this method.

When an ApplicationContextis loaded, it automatically searches for a MessageSourcebean defined in the context. The bean must have the name messageSource. If such a bean is found, all calls to the preceding methods are delegated to the message source. If no message source is found, the ApplicationContextattempts to find a parent containing a bean with the same name. If it does, it uses that bean as the MessageSource. If the ApplicationContextcannot find any source for messages, an empty DelegatingMessageSourceis instantiated in order to be able to accept calls to the methods defined above.

Spring provides two MessageSourceimplementations, ResourceBundleMessageSourceand StaticMessageSource. Both implement HierarchicalMessageSourcein order to do nested messaging. The StaticMessageSourceis rarely used but provides programmatic ways to add messages to the source. The ResourceBundleMessageSourceis shown in the following example:

								<beans>
								<bean
								id=
								"messageSource"
								class=
								"org.springframework.context.support.ResourceBundleMessageSource"
								>
								<property
								name=
								"basenames"
								>
								<list>
								<value>format
								</value>
								<value>exceptions
								</value>
								<value>windows
								</value>
								</list>
								</property>
								</bean>
								</beans>

In the example it is assumed you have three resource bundles defined in your classpath called format, exceptionsand windows. Any request to resolve a message will be handled in the JDK standard way of resolving messages through ResourceBundles. For the purposes of the example, assume the contents of two of the above resource bundle files are…​

# in format.properties message=Alligators rock!
# in exceptions.properties argument.required=The {
								0} argument is required.

A program to execute the MessageSourcefunctionality is shown in the next example. Remember that all ApplicationContextimplementations are also MessageSourceimplementations and so can be cast to the MessageSourceinterface.

								public
								static
								voidmain(String[] args) { MessageSource resources =
								newClassPathXmlApplicationContext(
								"beans.xml"); String message = resources.getMessage(
								"message", null,
								"Default", null); System.out.println(message); }

The resulting output from the above program will be…​

Alligators rock!

So to summarize, the MessageSourceis defined in a file called beans.xml, which exists at the root of your classpath. The messageSourcebean definition refers to a number of resource bundles through its basenamesproperty. The three files that are passed in the list to the basenamesproperty exist as files at the root of your classpath and are called format.properties, exceptions.properties, and windows.propertiesrespectively.

The next example shows arguments passed to the message lookup; these arguments will be converted into Strings and inserted into placeholders in the lookup message.

								<beans>
								<!-- this MessageSource is being used in a web application -->
								<bean
								id=
								"messageSource"
								class=
								"org.springframework.context.support.ResourceBundleMessageSource"
								>
								<property
								name=
								"basename"
								value=
								"exceptions"
								/>
								</bean>
								<!-- lets inject the above MessageSource into this POJO -->
								<bean
								id=
								"example"
								class=
								"com.foo.Example"
								>
								<property
								name=
								"messages"
								ref=
								"messageSource"
								/>
								</bean>
								</beans>
								public
								classExample {
								privateMessageSource messages;
								public
								voidsetMessages(MessageSource messages) {
								this.messages = messages; }
								public
								voidexecute() { String message =
								this.messages.getMessage(
								"argument.required",
								newObject [] {
								"userDao"},
								"Required", null); System.out.println(message); } }

The resulting output from the invocation of the execute()method will be…​

The userDao argument is required.

With regard to internationalization (i18n), Spring’s various MessageSourceimplementations follow the same locale resolution and fallback rules as the standard JDK ResourceBundle. In short, and continuing with the example messageSourcedefined previously, if you want to resolve messages against the British ( en-GB) locale, you would create files called format_en_GB.properties, exceptions_en_GB.properties, and windows_en_GB.propertiesrespectively.

Typically, locale resolution is managed by the surrounding environment of the application. In this example, the locale against which (British) messages will be resolved is specified manually.

# in exceptions_en_GB.properties argument.required=Ebagum lad, the {0} argument is required, I say, required.
								public
								static
								voidmain(
								finalString[] args) { MessageSource resources =
								newClassPathXmlApplicationContext(
								"beans.xml"); String message = resources.getMessage(
								"argument.required",
								newObject [] {
								"userDao"},
								"Required", Locale.UK); System.out.println(message); }

The resulting output from the running of the above program will be…​

Ebagum lad, the 'userDao' argument is required, I say, required.

You can also use the MessageSourceAwareinterface to acquire a reference to any MessageSourcethat has been defined. Any bean that is defined in an ApplicationContextthat implements the MessageSourceAwareinterface is injected with the application context’s MessageSourcewhen the bean is created and configured.

[Note] Note

As an alternative to ResourceBundleMessageSource, Spring provides a ReloadableResourceBundleMessageSourceclass. This variant supports the same bundle file format but is more flexible than the standard JDK based ResourceBundleMessageSourceimplementation.In particular, it allows for reading files from any Spring resource location (not just from the classpath) and supports hot reloading of bundle property files (while efficiently caching them in between). Check out the ReloadableResourceBundleMessageSourcejavadocs for details.

7.15.2 Standard and Custom Events

Event handling in the ApplicationContextis provided through the ApplicationEventclass and ApplicationListenerinterface. If a bean that implements the ApplicationListenerinterface is deployed into the context, every time an ApplicationEventgets published to the ApplicationContext, that bean is notified. Essentially, this is the standard Observerdesign pattern.

[Tip] Tip

As of Spring 4.2, the event infrastructure has been significantly improved and offer an annotation-based modelas well as the ability to publish any arbitrary event, that is an object that does not necessarily extend from ApplicationEvent. When such an object is published we wrap it in an event for you.

Spring provides the following standard events:

Table 7.7. Built-in Events

Event Explanation

ContextRefreshedEvent

Published when the ApplicationContextis initialized or refreshed, for example, using the refresh()method on the ConfigurableApplicationContextinterface. "Initialized" here means that all beans are loaded, post-processor beans are detected and activated, singletons are pre-instantiated, and the ApplicationContextobject is ready for use. As long as the context has not been closed, a refresh can be triggered multiple times, provided that the chosen ApplicationContextactually supports such "hot" refreshes. For example, XmlWebApplicationContextsupports hot refreshes, but GenericApplicationContextdoes not.

ContextStartedEvent

Published when the ApplicationContextis started, using the start()method on the ConfigurableApplicationContextinterface. "Started" here means that all Lifecyclebeans receive an explicit start signal. Typically this signal is used to restart beans after an explicit stop, but it may also be used to start components that have not been configured for autostart , for example, components that have not already started on initialization.

ContextStoppedEvent

Published when the ApplicationContextis stopped, using the stop()method on the ConfigurableApplicationContextinterface. "Stopped" here means that all Lifecyclebeans receive an explicit stop signal. A stopped context may be restarted through a start()call.

ContextClosedEvent

Published when the ApplicationContextis closed, using the close()method on the ConfigurableApplicationContextinterface. "Closed" here means that all singleton beans are destroyed. A closed context reaches its end of life; it cannot be refreshed or restarted.

RequestHandledEvent

A web-specific event telling all beans that an HTTP request has been serviced. This event is published afterthe request is complete. This event is only applicable to web applications using Spring’s DispatcherServlet.

You can also create and publish your own custom events. This example demonstrates a simple class that extends Spring’s ApplicationEventbase class:

								public
								classBlackListEvent
								extendsApplicationEvent {
								private
								finalString address;
								private
								finalString test;
								publicBlackListEvent(Object source, String address, String test) {
								super(source);
								this.address = address;
								this.test = test; }
								// accessor and other methods...}

To publish a custom ApplicationEvent, call the publishEvent()method on an ApplicationEventPublisher. Typically this is done by creating a class that implements ApplicationEventPublisherAwareand registering it as a Spring bean. The following example demonstrates such a class:

								public
								classEmailService
								implementsApplicationEventPublisherAware {
								privateList<String> blackList;
								privateApplicationEventPublisher publisher;
								public
								voidsetBlackList(List<String> blackList) {
								this.blackList = blackList; }
								public
								voidsetApplicationEventPublisher(ApplicationEventPublisher publisher) {
								this.publisher = publisher; }
								public
								voidsendEmail(String address, String text) {
								if(blackList.contains(address)) { BlackListEvent event =
								newBlackListEvent(
								this, address, text); publisher.publishEvent(event);
								return; }
								// send email...} }

At configuration time, the Spring container will detect that EmailServiceimplements ApplicationEventPublisherAwareand will automatically call setApplicationEventPublisher(). In reality, the parameter passed in will be the Spring container itself; you’re simply interacting with the application context via its ApplicationEventPublisherinterface.

To receive the custom ApplicationEvent, create a class that implements ApplicationListenerand register it as a Spring bean. The following example demonstrates such a class:

								public
								classBlackListNotifier
								implementsApplicationListener<BlackListEvent> {
								privateString notificationAddress;
								public
								voidsetNotificationAddress(String notificationAddress) {
								this.notificationAddress = notificationAddress; }
								public
								voidonApplicationEvent(BlackListEvent event) {
								// notify appropriate parties via notificationAddress...} }

Notice that ApplicationListeneris generically parameterized with the type of your custom event, BlackListEvent. This means that the onApplicationEvent()method can remain type-safe, avoiding any need for downcasting. You may register as many event listeners as you wish, but note that by default event listeners receive events synchronously. This means the publishEvent()method blocks until all listeners have finished processing the event. One advantage of this synchronous and single-threaded approach is that when a listener receives an event, it operates inside the transaction context of the publisher if a transaction context is available. If another strategy for event publication becomes necessary, refer to the JavaDoc for Spring’s ApplicationEventMulticasterinterface.

The following example shows the bean definitions used to register and configure each of the classes above:

								<bean
								id=
								"emailService"
								class=
								"example.EmailService"
								>
								<property
								name=
								"blackList"
								>
								<list>
								<value>known.spammer@example.org
								</value>
								<value>known.hacker@example.org
								</value>
								<value>john.doe@example.org
								</value>
								</list>
								</property>
								</bean>
								<bean
								id=
								"blackListNotifier"
								class=
								"example.BlackListNotifier"
								>
								<property
								name=
								"notificationAddress"
								value=
								"blacklist@example.org"
								/>
								</bean>

Putting it all together, when the sendEmail()method of the emailServicebean is called, if there are any emails that should be blacklisted, a custom event of type BlackListEventis published. The blackListNotifierbean is registered as an ApplicationListenerand thus receives the BlackListEvent, at which point it can notify appropriate parties.

[Note] Note

Spring’s eventing mechanism is designed for simple communication between Spring beans within the same application context. However, for more sophisticated enterprise integration needs, the separately-maintained Spring Integrationproject provides complete support for building lightweight, pattern-oriented, event-driven architectures that build upon the well-known Spring programming model.

Annotation-based Event Listeners

As of Spring 4.2, an event listener can be registered on any public method of a managed bean via the EventListenerannotation. The BlackListNotifiercan be rewritten as follows:

									public
									classBlackListNotifier {
									privateString notificationAddress;
									public
									voidsetNotificationAddress(String notificationAddress) {
									this.notificationAddress = notificationAddress; }
									
										@EventListener
									public
									voidprocessBlackListEvent(BlackListEvent event) {
									// notify appropriate parties via notificationAddress...} }

As you can see above, the method signature actually inferwhich even type it listens to. This also works for nested generics as long as the actual event resolves the generics parameter you would filter on.

If your method should listen to several events or if you want to define it with no parameter at all, the event type(s) can also be specified on the annotation itself:

									
										@EventListener({ContextStartedEvent.class, ContextRefreshedEvent.class})
									public
									voidhandleContextStart() { }

It is also possible to add additional runtime filtering via the conditionattribute of the annotation that defines a SpELexpressionthat should match to actually invoke the method for a particular event.

For instance, our notifier can be rewritten to be only invoked if the testattribute of the event is equal to foo:

									
										@EventListener(condition = "#blEvent.test == 'foo'")
									public
									voidprocessBlackListEvent(BlackListEvent blEvent) {
									// notify appropriate parties via notificationAddress...}

Each SpELexpression evaluates again a dedicated context. The next table lists the items made available to the context so one can use them for conditional event processing:

Table 7.8. Event SpEL available metadata

Name Location Description Example

Event

root object

The actual ApplicationEvent

#root.event

Arguments array

root object

The arguments (as array) used for invoking the target

#root.args[0]

Argument name

evaluation context

Name of any of the method arguments. If for some reason the names are not available (e.g. no debug information), the argument names are also available under the #a<#arg>where #argstands for the argument index (starting from 0).

#blEventor #a0(one can also use #p0or #p<#arg>notation as an alias).

Note that #root.eventallows you to access to the underlying event, even if your method signature actually refers to an arbitrary object that was published.

If you need to publish an event as the result of processing another, just change the method signature to return the event that should be published, something like:

									
										@EventListener
									publicListUpdateEvent handleBlackListEvent(BlackListEvent event) {
									// notify appropriate parties via notificationAddress and
									// then publish a ListUpdateEvent...}
[Note] Note

This feature is not supported for asynchronous listeners.

This new method will publish a new ListUpdateEventfor every BlackListEventhandled by the method above. If you need to publish several events, just return a Collectionof events instead.

Asynchronous Listeners

If you want a particular listener to process events asynchronously, simply reuse the regular @Asyncsupport:

									
										@EventListener
									
										@Async
									public
									voidprocessBlackListEvent(BlackListEvent event) {
									// BlackListEvent is processed in a separate thread}

Be aware of the following limitations when using asynchronous events:

  1. If the event listener throws an Exceptionit will not be propagated to the caller, check AsyncUncaughtExceptionHandlerfor more details.
  2. Such event listener cannot send replies. If you need to send another event as the result of the processing, inject ApplicationEventPublisherto send the event manually.

Ordering Listeners

If you need the listener to be invoked before another one, just add the @Orderannotation to the method declaration:

									
										@EventListener
									
										@Order(42)
									public
									voidprocessBlackListEvent(BlackListEvent event) {
									// notify appropriate parties via notificationAddress...}

Generic Events

You may also use generics to further define the structure of your event. Consider an EntityCreatedEvent<T>where Tis the type of the actual entity that got created. You can create the following listener definition to only receive EntityCreatedEventfor a Person:

									
										@EventListener
									public
									voidonPersonCreated(EntityCreatedEvent<Person> event) { ... }

Due to type erasure, this will only work if the event that is fired resolves the generic parameter(s) on which the event listener filters on (that is something like class PersonCreatedEvent extends EntityCreatedEvent<Person> { …​ }).

In certain circumstances, this may become quite tedious if all events follow the same structure (as it should be the case for the event above). In such a case, you can implement ResolvableTypeProviderto guidethe framework beyond what the runtime environment provides:

									public
									classEntityCreatedEvent<T>
									extendsApplicationEvent
									implementsResolvableTypeProvider {
									publicEntityCreatedEvent(T entity) {
									super(entity); }
									
										@Override
									publicResolvableType getResolvableType() {
									returnResolvableType.forClassWithGenerics(getClass(), ResolvableType.forInstance(getSource())); } }
[Tip] Tip

This works not only for ApplicationEventbut any arbitrary object that you’d send as an event.

7.15.3 Convenient access to low-level resources

For optimal usage and understanding of application contexts, users should generally familiarize themselves with Spring’s Resourceabstraction, as described in the chapter Chapter 8, Resources .

An application context is a ResourceLoader, which can be used to load Resources. A Resourceis essentially a more feature rich version of the JDK class java.net.URL, in fact, the implementations of the Resourcewrap an instance of java.net.URLwhere appropriate. A Resourcecan obtain low-level resources from almost any location in a transparent fashion, including from the classpath, a filesystem location, anywhere describable with a standard URL, and some other variations. If the resource location string is a simple path without any special prefixes, where those resources come from is specific and appropriate to the actual application context type.

You can configure a bean deployed into the application context to implement the special callback interface, ResourceLoaderAware, to be automatically called back at initialization time with the application context itself passed in as the ResourceLoader. You can also expose properties of type Resource, to be used to access static resources; they will be injected into it like any other properties. You can specify those Resourceproperties as simple String paths, and rely on a special JavaBean PropertyEditorthat is automatically registered by the context, to convert those text strings to actual Resourceobjects when the bean is deployed.

The location path or paths supplied to an ApplicationContextconstructor are actually resource strings, and in simple form are treated appropriately to the specific context implementation. ClassPathXmlApplicationContexttreats a simple location path as a classpath location. You can also use location paths (resource strings) with special prefixes to force loading of definitions from the classpath or a URL, regardless of the actual context type.

7.15.4 Convenient ApplicationContext instantiation for web applications

You can create ApplicationContextinstances declaratively by using, for example, a ContextLoader. Of course you can also create ApplicationContextinstances programmatically by using one of the ApplicationContextimplementations.

You can register an ApplicationContextusing the ContextLoaderListeneras follows:

								<context-param>
								<param-name>contextConfigLocation
								</param-name>
								<param-value>/WEB-INF/daoContext.xml /WEB-INF/applicationContext.xml
								</param-value>
								</context-param>
								<listener>
								<listener-class>org.springframework.web.context.ContextLoaderListener
								</listener-class>
								</listener>

The listener inspects the contextConfigLocationparameter. If the parameter does not exist, the listener uses /WEB-INF/applicationContext.xmlas a default. When the parameter doesexist, the listener separates the String by using predefined delimiters (comma, semicolon and whitespace) and uses the values as locations where application contexts will be searched. Ant-style path patterns are supported as well. Examples are /WEB-INF/*Context.xmlfor all files with names ending with "Context.xml", residing in the "WEB-INF" directory, and /WEB-INF/**/*Context.xml, for all such files in any subdirectory of "WEB-INF".

7.15.5 Deploying a Spring ApplicationContext as a Java EE RAR file

It is possible to deploy a Spring ApplicationContext as a RAR file, encapsulating the context and all of its required bean classes and library JARs in a Java EE RAR deployment unit. This is the equivalent of bootstrapping a standalone ApplicationContext, just hosted in Java EE environment, being able to access the Java EE servers facilities. RAR deployment is more natural alternative to scenario of deploying a headless WAR file, in effect, a WAR file without any HTTP entry points that is used only for bootstrapping a Spring ApplicationContext in a Java EE environment.

RAR deployment is ideal for application contexts that do not need HTTP entry points but rather consist only of message endpoints and scheduled jobs. Beans in such a context can use application server resources such as the JTA transaction manager and JNDI-bound JDBC DataSources and JMS ConnectionFactory instances, and may also register with the platform’s JMX server - all through Spring’s standard transaction management and JNDI and JMX support facilities. Application components can also interact with the application server’s JCA WorkManager through Spring’s TaskExecutorabstraction.

Check out the JavaDoc of the SpringContextResourceAdapterclass for the configuration details involved in RAR deployment.

For a simple deployment of a Spring ApplicationContext as a Java EE RAR file:package all application classes into a RAR file, which is a standard JAR file with a different file extension. Add all required library JARs into the root of the RAR archive. Add a "META-INF/ra.xml" deployment descriptor (as shown in SpringContextResourceAdapters JavaDoc) and the corresponding Spring XML bean definition file(s) (typically "META-INF/applicationContext.xml"), and drop the resulting RAR file into your application server’s deployment directory.

[Note] Note

Such RAR deployment units are usually self-contained; they do not expose components to the outside world, not even to other modules of the same application. Interaction with a RAR-based ApplicationContext usually occurs through JMS destinations that it shares with other modules. A RAR-based ApplicationContext may also, for example, schedule some jobs, reacting to new files in the file system (or the like). If it needs to allow synchronous access from the outside, it could for example export RMI endpoints, which of course may be used by other application modules on the same machine.

7.16 The BeanFactory

The BeanFactoryprovides the underlying basis for Spring’s IoC functionality but it is only used directly in integration with other third-party frameworks and is now largely historical in nature for most users of Spring. The BeanFactoryand related interfaces, such as BeanFactoryAware, InitializingBean, DisposableBean, are still present in Spring for the purposes of backward compatibility with the large number of third-party frameworks that integrate with Spring. Often third-party components that can not use more modern equivalents such as @PostConstructor @PreDestroyin order to remain compatible with JDK 1.4 or to avoid a dependency on JSR-250.

This section provides additional background into the differences between the BeanFactoryand ApplicationContextand how one might access the IoC container directly through a classic singleton lookup.

7.16.1 BeanFactory or ApplicationContext?

Use an ApplicationContextunless you have a good reason for not doing so.

Because the ApplicationContextincludes all functionality of the BeanFactory, it is generally recommended over the BeanFactory, except for a few situations such as in embedded applications running on resource-constrained devices where memory consumption might be critical and a few extra kilobytes might make a difference. However, for most typical enterprise applications and systems, the ApplicationContextis what you will want to use. Spring makes heavyuse of the BeanPostProcessorextension point(to effect proxying and so on). If you use only a plain BeanFactory, a fair amount of support such as transactions and AOP will not take effect, at least not without some extra steps on your part. This situation could be confusing because nothing is actually wrong with the configuration.

The following table lists features provided by the BeanFactoryand ApplicationContextinterfaces and implementations.

Table 7.9. Feature Matrix

Feature BeanFactory ApplicationContext

Bean instantiation/wiring

Yes

Yes

Automatic BeanPostProcessorregistration

No

Yes

Automatic BeanFactoryPostProcessorregistration

No

Yes

Convenient MessageSourceaccess (for i18n)

No

Yes

ApplicationEventpublication

No

Yes

To explicitly register a bean post-processor with a BeanFactoryimplementation, you need to write code like this:

DefaultListableBeanFactory factory =
								newDefaultListableBeanFactory();
								// populate the factory with bean definitions
								// now register any needed BeanPostProcessor instancesMyBeanPostProcessor postProcessor =
								newMyBeanPostProcessor(); factory.addBeanPostProcessor(postProcessor);
								// now start using the factory

To explicitly register a BeanFactoryPostProcessorwhen using a BeanFactoryimplementation, you must write code like this:

DefaultListableBeanFactory factory =
								newDefaultListableBeanFactory(); XmlBeanDefinitionReader reader =
								newXmlBeanDefinitionReader(factory); reader.loadBeanDefinitions(
								newFileSystemResource(
								"beans.xml"));
								// bring in some property values from a Properties filePropertyPlaceholderConfigurer cfg =
								newPropertyPlaceholderConfigurer(); cfg.setLocation(
								newFileSystemResource(
								"jdbc.properties"));
								// now actually do the replacementcfg.postProcessBeanFactory(factory);

In both cases, the explicit registration step is inconvenient, which is one reason why the various ApplicationContextimplementations are preferred above plain BeanFactoryimplementations in the vast majority of Spring-backed applications, especially when using BeanFactoryPostProcessors and BeanPostProcessors. These mechanisms implement important functionality such as property placeholder replacement and AOP.

7.16.2 Glue code and the evil singleton

It is best to write most application code in a dependency-injection (DI) style, where that code is served out of a Spring IoC container, has its own dependencies supplied by the container when it is created, and is completely unaware of the container. However, for the small glue layers of code that are sometimes needed to tie other code together, you sometimes need a singleton (or quasi-singleton) style access to a Spring IoC container. For example, third-party code may try to construct new objects directly ( Class.forName()style), without the ability to get these objects out of a Spring IoC container.If the object constructed by the third-party code is a small stub or proxy, which then uses a singleton style access to a Spring IoC container to get a real object to delegate to, then inversion of control has still been achieved for the majority of the code (the object coming out of the container). Thus most code is still unaware of the container or how it is accessed, and remains decoupled from other code, with all ensuing benefits. EJBs may also use this stub/proxy approach to delegate to a plain Java implementation object, retrieved from a Spring IoC container. While the Spring IoC container itself ideally does not have to be a singleton, it may be unrealistic in terms of memory usage or initialization times (when using beans in the Spring IoC container such as a Hibernate SessionFactory) for each bean to use its own, non-singleton Spring IoC container.

Looking up the application context in a service locator style is sometimes the only option for accessing shared Spring-managed components, such as in an EJB 2.1 environment, or when you want to share a single ApplicationContext as a parent to WebApplicationContexts across WAR files. In this case you should look into using the utility class ContextSingletonBeanFactoryLocatorlocator that is described in this Spring team blog entry.


8. Resources

8.1 Introduction

Java’s standard java.net.URLclass and standard handlers for various URL prefixes unfortunately are not quite adequate enough for all access to low-level resources. For example, there is no standardized URLimplementation that may be used to access a resource that needs to be obtained from the classpath, or relative to a ServletContext. While it is possible to register new handlers for specialized URLprefixes (similar to existing handlers for prefixes such as http:), this is generally quite complicated, and the URLinterface still lacks some desirable functionality, such as a method to check for the existence of the resource being pointed to.

8.2 The Resource interface

Spring’s Resourceinterface is meant to be a more capable interface for abstracting access to low-level resources.

							public
							interfaceResource
							extendsInputStreamSource {
							booleanexists();
							booleanisOpen(); URL getURL()
							throwsIOException; File getFile()
							throwsIOException; Resource createRelative(String relativePath)
							throwsIOException; String getFilename(); String getDescription(); }
							public
							interfaceInputStreamSource { InputStream getInputStream()
							throwsIOException; }

Some of the most important methods from the Resourceinterface are:

  • getInputStream(): locates and opens the resource, returning an InputStreamfor reading from the resource. It is expected that each invocation returns a fresh InputStream. It is the responsibility of the caller to close the stream.
  • exists(): returns a booleanindicating whether this resource actually exists in physical form.
  • isOpen(): returns a booleanindicating whether this resource represents a handle with an open stream. If true, the InputStreamcannot be read multiple times, and must be read once only and then closed to avoid resource leaks. Will be falsefor all usual resource implementations, with the exception of InputStreamResource.
  • getDescription(): returns a description for this resource, to be used for error output when working with the resource. This is often the fully qualified file name or the actual URL of the resource.

Other methods allow you to obtain an actual URLor Fileobject representing the resource (if the underlying implementation is compatible, and supports that functionality).

The Resourceabstraction is used extensively in Spring itself, as an argument type in many method signatures when a resource is needed. Other methods in some Spring APIs (such as the constructors to various ApplicationContextimplementations), take a Stringwhich in unadorned or simple form is used to create a Resourceappropriate to that context implementation, or via special prefixes on the Stringpath, allow the caller to specify that a specific Resourceimplementation must be created and used.

While the Resourceinterface is used a lot with Spring and by Spring, it’s actually very useful to use as a general utility class by itself in your own code, for access to resources, even when your code doesn’t know or care about any other parts of Spring. While this couples your code to Spring, it really only couples it to this small set of utility classes, which are serving as a more capable replacement for URL, and can be considered equivalent to any other library you would use for this purpose.

It is important to note that the Resourceabstraction does not replace functionality: it wraps it where possible. For example, a UrlResourcewraps a URL, and uses the wrapped URLto do its work.

8.3 Built-in Resource implementations

There are a number of Resourceimplementations that come supplied straight out of the box in Spring:

8.3.1 UrlResource

The UrlResourcewraps a java.net.URL, and may be used to access any object that is normally accessible via a URL, such as files, an HTTP target, an FTP target, etc. All URLs have a standardized Stringrepresentation, such that appropriate standardized prefixes are used to indicate one URL type from another. This includes file:for accessing filesystem paths, http:for accessing resources via the HTTP protocol, ftp:for accessing resources via FTP, etc.

A UrlResourceis created by Java code explicitly using the UrlResourceconstructor, but will often be created implicitly when you call an API method which takes a Stringargument which is meant to represent a path. For the latter case, a JavaBeans PropertyEditorwill ultimately decide which type of Resourceto create. If the path string contains a few well-known (to it, that is) prefixes such as classpath:, it will create an appropriate specialized Resourcefor that prefix. However, if it doesn’t recognize the prefix, it will assume the this is just a standard URL string, and will create a UrlResource.

8.3.2 ClassPathResource

This class represents a resource which should be obtained from the classpath. This uses either the thread context class loader, a given class loader, or a given class for loading resources.

This Resourceimplementation supports resolution as java.io.Fileif the class path resource resides in the file system, but not for classpath resources which reside in a jar and have not been expanded (by the servlet engine, or whatever the environment is) to the filesystem. To address this the various Resourceimplementations always support resolution as a java.net.URL.

A ClassPathResourceis created by Java code explicitly using the ClassPathResourceconstructor, but will often be created implicitly when you call an API method which takes a Stringargument which is meant to represent a path. For the latter case, a JavaBeans PropertyEditorwill recognize the special prefix classpath:on the string path, and create a ClassPathResourcein that case.

8.3.3 FileSystemResource

This is a Resourceimplementation for java.io.Filehandles. It obviously supports resolution as a File, and as a URL.

8.3.4 ServletContextResource

This is a Resourceimplementation for ServletContextresources, interpreting relative paths within the relevant web application’s root directory.

This always supports stream access and URL access, but only allows java.io.Fileaccess when the web application archive is expanded and the resource is physically on the filesystem. Whether or not it’s expanded and on the filesystem like this, or accessed directly from the JAR or somewhere else like a DB (it’s conceivable) is actually dependent on the Servlet container.

8.3.5 InputStreamResource

A Resourceimplementation for a given InputStream. This should only be used if no specific Resourceimplementation is applicable. In particular, prefer ByteArrayResourceor any of the file-based Resourceimplementations where possible.

In contrast to other Resourceimplementations, this is a descriptor for an alreadyopened resource - therefore returning truefrom isOpen(). Do not use it if you need to keep the resource descriptor somewhere, or if you need to read a stream multiple times.

8.3.6 ByteArrayResource

This is a Resourceimplementation for a given byte array. It creates a ByteArrayInputStreamfor the given byte array.

It’s useful for loading content from any given byte array, without having to resort to a single-use InputStreamResource.

8.4 The ResourceLoader

The ResourceLoaderinterface is meant to be implemented by objects that can return (i.e. load) Resourceinstances.

							public
							interfaceResourceLoader { Resource getResource(String location); }

All application contexts implement the ResourceLoaderinterface, and therefore all application contexts may be used to obtain Resourceinstances.

When you call getResource()on a specific application context, and the location path specified doesn’t have a specific prefix, you will get back a Resourcetype that is appropriate to that particular application context. For example, assume the following snippet of code was executed against a ClassPathXmlApplicationContextinstance:

Resource template = ctx.getResource(
							"some/resource/path/myTemplate.txt");

What would be returned would be a ClassPathResource; if the same method was executed against a FileSystemXmlApplicationContextinstance, you’d get back a FileSystemResource. For a WebApplicationContext, you’d get back a ServletContextResource, and so on.

As such, you can load resources in a fashion appropriate to the particular application context.

On the other hand, you may also force ClassPathResourceto be used, regardless of the application context type, by specifying the special classpath:prefix:

Resource template = ctx.getResource(
							"classpath:some/resource/path/myTemplate.txt");

Similarly, one can force a UrlResourceto be used by specifying any of the standard java.net.URLprefixes:

Resource template = ctx.getResource(
							"file:///some/resource/path/myTemplate.txt");
Resource template = ctx.getResource(
							"http://myhost.com/resource/path/myTemplate.txt");

The following table summarizes the strategy for converting Strings to Resources:

Table 8.1. Resource strings

Prefix Example Explanation

classpath:

classpath:com/myapp/config.xml

Loaded from the classpath.

file:

file:///data/config.xml

Loaded as a URL, from the filesystem. [1]

http:

http://myserver/logo.png

Loaded as a URL.

(none)

/data/config.xml

Depends on the underlying ApplicationContext.

8.5 The ResourceLoaderAware interface

The ResourceLoaderAwareinterface is a special marker interface, identifying objects that expect to be provided with a ResourceLoaderreference.

							public
							interfaceResourceLoaderAware {
							voidsetResourceLoader(ResourceLoader resourceLoader); }

When a class implements ResourceLoaderAwareand is deployed into an application context (as a Spring-managed bean), it is recognized as ResourceLoaderAwareby the application context. The application context will then invoke the setResourceLoader(ResourceLoader), supplying itself as the argument (remember, all application contexts in Spring implement the ResourceLoaderinterface).

Of course, since an ApplicationContextis a ResourceLoader, the bean could also implement the ApplicationContextAwareinterface and use the supplied application context directly to load resources, but in general, it’s better to use the specialized ResourceLoaderinterface if that’s all that’s needed. The code would just be coupled to the resource loading interface, which can be considered a utility interface, and not the whole Spring ApplicationContextinterface.

As of Spring 2.5, you can rely upon autowiring of the ResourceLoaderas an alternative to implementing the ResourceLoaderAwareinterface. The "traditional" constructorand byTypeautowiring modes (as described in Section 7.4.5, “Autowiring collaborators”) are now capable of providing a dependency of type ResourceLoaderfor either a constructor argument or setter method parameter respectively. For more flexibility (including the ability to autowire fields and multiple parameter methods), consider using the new annotation-based autowiring features. In that case, the ResourceLoaderwill be autowired into a field, constructor argument, or method parameter that is expecting the ResourceLoadertype as long as the field, constructor, or method in question carries the @Autowiredannotation. For more information, see Section 7.9.2, “@Autowired”.

8.6 Resources as dependencies

If the bean itself is going to determine and supply the resource path through some sort of dynamic process, it probably makes sense for the bean to use the ResourceLoaderinterface to load resources. Consider as an example the loading of a template of some sort, where the specific resource that is needed depends on the role of the user. If the resources are static, it makes sense to eliminate the use of the ResourceLoaderinterface completely, and just have the bean expose the Resourceproperties it needs, and expect that they will be injected into it.

What makes it trivial to then inject these properties, is that all application contexts register and use a special JavaBeans PropertyEditorwhich can convert Stringpaths to Resourceobjects. So if myBeanhas a template property of type Resource, it can be configured with a simple string for that resource, as follows:

							<bean
							id=
							"myBean"
							class=
							"..."
							>
							<property
							name=
							"template"
							value=
							"some/resource/path/myTemplate.txt"
							/>
							</bean>

Note that the resource path has no prefix, so because the application context itself is going to be used as the ResourceLoader, the resource itself will be loaded via a ClassPathResource, FileSystemResource, or ServletContextResource(as appropriate) depending on the exact type of the context.

If there is a need to force a specific Resourcetype to be used, then a prefix may be used. The following two examples show how to force a ClassPathResourceand a UrlResource(the latter being used to access a filesystem file).

							<property
							name=
							"template"
							value=
							"classpath:some/resource/path/myTemplate.txt"
							>
							<property
							name=
							"template"
							value=
							"file:///some/resource/path/myTemplate.txt"
							/>

8.7 Application contexts and Resource paths

8.7.1 Constructing application contexts

An application context constructor (for a specific application context type) generally takes a string or array of strings as the location path(s) of the resource(s) such as XML files that make up the definition of the context.

When such a location path doesn’t have a prefix, the specific Resourcetype built from that path and used to load the bean definitions, depends on and is appropriate to the specific application context. For example, if you create a ClassPathXmlApplicationContextas follows:

ApplicationContext ctx =
								newClassPathXmlApplicationContext(
								"conf/appContext.xml");

The bean definitions will be loaded from the classpath, as a ClassPathResourcewill be used. But if you create a FileSystemXmlApplicationContextas follows:

ApplicationContext ctx =
								newFileSystemXmlApplicationContext(
								"conf/appContext.xml");

The bean definition will be loaded from a filesystem location, in this case relative to the current working directory.

Note that the use of the special classpath prefix or a standard URL prefix on the location path will override the default type of Resourcecreated to load the definition. So this FileSystemXmlApplicationContext…​

ApplicationContext ctx =
								newFileSystemXmlApplicationContext(
								"classpath:conf/appContext.xml");
  1. will actually load its bean definitions from the classpath. However, it is still a FileSystemXmlApplicationContext. If it is subsequently used as a ResourceLoader, any unprefixed paths will still be treated as filesystem paths.

Constructing ClassPathXmlApplicationContext instances - shortcuts

The ClassPathXmlApplicationContextexposes a number of constructors to enable convenient instantiation. The basic idea is that one supplies merely a string array containing just the filenames of the XML files themselves (without the leading path information), and one alsosupplies a Class; the ClassPathXmlApplicationContextwill derive the path information from the supplied class.

An example will hopefully make this clear. Consider a directory layout that looks like this:

com/ foo/ services.xml daos.xml MessengerService.class

A ClassPathXmlApplicationContextinstance composed of the beans defined in the 'services.xml'and 'daos.xml'could be instantiated like so…​

ApplicationContext ctx =
									newClassPathXmlApplicationContext(
									newString[] {
									"services.xml",
									"daos.xml"}, MessengerService.
									class);

Please do consult the ClassPathXmlApplicationContextjavadocs for details on the various constructors.

8.7.2 Wildcards in application context constructor resource paths

The resource paths in application context constructor values may be a simple path (as shown above) which has a one-to-one mapping to a target Resource, or alternately may contain the special "classpath*:" prefix and/or internal Ant-style regular expressions (matched using Spring’s PathMatcherutility). Both of the latter are effectively wildcards

One use for this mechanism is when doing component-style application assembly. All components can 'publish' context definition fragments to a well-known location path, and when the final application context is created using the same path prefixed via classpath*:, all component fragments will be picked up automatically.

Note that this wildcarding is specific to use of resource paths in application context constructors (or when using the PathMatcherutility class hierarchy directly), and is resolved at construction time. It has nothing to do with the Resourcetype itself. It’s not possible to use the classpath*:prefix to construct an actual Resource, as a resource points to just one resource at a time.

Ant-style Patterns

When the path location contains an Ant-style pattern, for example:

/WEB-INF/*-context.xml com/mycompany/**/applicationContext.xml file:C:/some/path/*-context.xml classpath:com/mycompany/**/applicationContext.xml

The resolver follows a more complex but defined procedure to try to resolve the wildcard. It produces a Resource for the path up to the last non-wildcard segment and obtains a URL from it. If this URL is not a jar:URL or container-specific variant (e.g. zip:in WebLogic, wsjarin WebSphere, etc.), then a java.io.Fileis obtained from it and used to resolve the wildcard by traversing the filesystem. In the case of a jar URL, the resolver either gets a java.net.JarURLConnectionfrom it or manually parses the jar URL and then traverses the contents of the jar file to resolve the wildcards.

Implications on portability

If the specified path is already a file URL (either explicitly, or implicitly because the base ResourceLoaderis a filesystem one, then wildcarding is guaranteed to work in a completely portable fashion.

If the specified path is a classpath location, then the resolver must obtain the last non-wildcard path segment URL via a Classloader.getResource()call. Since this is just a node of the path (not the file at the end) it is actually undefined (in the ClassLoaderjavadocs) exactly what sort of a URL is returned in this case. In practice, it is always a java.io.Filerepresenting the directory, where the classpath resource resolves to a filesystem location, or a jar URL of some sort, where the classpath resource resolves to a jar location. Still, there is a portability concern on this operation.

If a jar URL is obtained for the last non-wildcard segment, the resolver must be able to get a java.net.JarURLConnectionfrom it, or manually parse the jar URL, to be able to walk the contents of the jar, and resolve the wildcard. This will work in most environments, but will fail in others, and it is strongly recommended that the wildcard resolution of resources coming from jars be thoroughly tested in your specific environment before you rely on it.

The Classpath*: portability classpath*: prefix

When constructing an XML-based application context, a location string may use the special classpath*:prefix:

ApplicationContext ctx =
									newClassPathXmlApplicationContext(
									"classpath*:conf/appContext.xml");

This special prefix specifies that all classpath resources that match the given name must be obtained (internally, this essentially happens via a ClassLoader.getResources(…​)call), and then merged to form the final application context definition.

[Note] Note

The wildcard classpath relies on the getResources()method of the underlying classloader. As most application servers nowadays supply their own classloader implementation, the behavior might differ especially when dealing with jar files. A simple test to check if classpath*works is to use the classloader to load a file from within a jar on the classpath: getClass().getClassLoader().getResources("<someFileInsideTheJar>"). Try this test with files that have the same name but are placed inside two different locations. In case an inappropriate result is returned, check the application server documentation for settings that might affect the classloader behavior.

The classpath*:prefix can also be combined with a PathMatcherpattern in the rest of the location path, for example classpath*:META-INF/*-beans.xml. In this case, the resolution strategy is fairly simple: a ClassLoader.getResources()call is used on the last non-wildcard path segment to get all the matching resources in the class loader hierarchy, and then off each resource the same PathMatcher resolution strategy described above is used for the wildcard subpath.

Other notes relating to wildcards

Please note that classpath*:when combined with Ant-style patterns will only work reliably with at least one root directory before the pattern starts, unless the actual target files reside in the file system. This means that a pattern like classpath*:*.xmlwill not retrieve files from the root of jar files but rather only from the root of expanded directories. This originates from a limitation in the JDK’s ClassLoader.getResources()method which only returns file system locations for a passed-in empty string (indicating potential roots to search).

Ant-style patterns with classpath:resources are not guaranteed to find matching resources if the root package to search is available in multiple class path locations. This is because a resource such as

com/mycompany/package1/service-context.xml

may be in only one location, but when a path such as

classpath:com/mycompany/**/service-context.xml

is used to try to resolve it, the resolver will work off the (first) URL returned by getResource("com/mycompany");. If this base package node exists in multiple classloader locations, the actual end resource may not be underneath. Therefore, preferably, use " `classpath*:`" with the same Ant-style pattern in such a case, which will search all class path locations that contain the root package.

8.7.3 FileSystemResource caveats

A FileSystemResourcethat is not attached to a FileSystemApplicationContext(that is, a FileSystemApplicationContextis not the actual ResourceLoader) will treat absolute vs. relative paths as you would expect. Relative paths are relative to the current working directory, while absolute paths are relative to the root of the filesystem.

For backwards compatibility (historical) reasons however, this changes when the FileSystemApplicationContextis the ResourceLoader. The FileSystemApplicationContextsimply forces all attached FileSystemResourceinstances to treat all location paths as relative, whether they start with a leading slash or not. In practice, this means the following are equivalent:

ApplicationContext ctx =
								newFileSystemXmlApplicationContext(
								"conf/context.xml");
ApplicationContext ctx =
								newFileSystemXmlApplicationContext(
								"/conf/context.xml");

As are the following: (Even though it would make sense for them to be different, as one case is relative and the other absolute.)

FileSystemXmlApplicationContext ctx = ...; ctx.getResource(
								"some/resource/path/myTemplate.txt");
FileSystemXmlApplicationContext ctx = ...; ctx.getResource(
								"/some/resource/path/myTemplate.txt");

In practice, if true absolute filesystem paths are needed, it is better to forgo the use of absolute paths with FileSystemResource/ FileSystemXmlApplicationContext, and just force the use of a UrlResource, by using the file:URL prefix.

								// actual context type doesn't matter, the Resource will always be UrlResourcectx.getResource(
								"file:///some/resource/path/myTemplate.txt");
								// force this FileSystemXmlApplicationContext to load its definition via a UrlResourceApplicationContext ctx =
								newFileSystemXmlApplicationContext(
								"file:///conf/context.xml");

9. Validation, Data Binding, and Type Conversion

9.1 Introduction

JSR-303/JSR-349 Bean Validation

Spring Framework 4.0 supports Bean Validation 1.0 (JSR-303) and Bean Validation 1.1 (JSR-349) in terms of setup support, also adapting it to Spring’s Validatorinterface.

An application can choose to enable Bean Validation once globally, as described in Section 9.8, “Spring Validation”, and use it exclusively for all validation needs.

An application can also register additional Spring Validatorinstances per DataBinderinstance, as described in Section 9.8.3, “Configuring a DataBinder”. This may be useful for plugging in validation logic without the use of annotations.

There are pros and cons for considering validation as business logic, and Spring offers a design for validation (and data binding) that does not exclude either one of them. Specifically validation should not be tied to the web tier, should be easy to localize and it should be possible to plug in any validator available. Considering the above, Spring has come up with a Validatorinterface that is both basic and eminently usable in every layer of an application.

Data binding is useful for allowing user input to be dynamically bound to the domain model of an application (or whatever objects you use to process user input). Spring provides the so-called DataBinderto do exactly that. The Validatorand the DataBindermake up the validationpackage, which is primarily used in but not limited to the MVC framework.

The BeanWrapperis a fundamental concept in the Spring Framework and is used in a lot of places. However, you probably will not have the need to use the BeanWrapperdirectly. Because this is reference documentation however, we felt that some explanation might be in order. We will explain the BeanWrapperin this chapter since, if you were going to use it at all, you would most likely do so when trying to bind data to objects.

Spring’s DataBinder and the lower-level BeanWrapper both use PropertyEditors to parse and format property values. The PropertyEditorconcept is part of the JavaBeans specification, and is also explained in this chapter. Spring 3 introduces a "core.convert" package that provides a general type conversion facility, as well as a higher-level "format" package for formatting UI field values. These new packages may be used as simpler alternatives to PropertyEditors, and will also be discussed in this chapter.

9.2 Validation using Spring’s Validator interface

Spring features a Validatorinterface that you can use to validate objects. The Validatorinterface works using an Errorsobject so that while validating, validators can report validation failures to the Errorsobject.

Let’s consider a small data object:

							public
							classPerson {
							privateString name;
							private
							intage;
							// the usual getters and setters...}

We’re going to provide validation behavior for the Personclass by implementing the following two methods of the org.springframework.validation.Validatorinterface:

  • supports(Class)- Can this Validatorvalidate instances of the supplied Class?
  • validate(Object, org.springframework.validation.Errors)- validates the given object and in case of validation errors, registers those with the given Errorsobject

Implementing a Validatoris fairly straightforward, especially when you know of the ValidationUtilshelper class that the Spring Framework also provides.

							public
							classPersonValidator
							implementsValidator {
							/** * This Validator validates *just* Person instances */
							public
							booleansupports(Class clazz) {
							returnPerson.
							class.equals(clazz); }
							public
							voidvalidate(Object obj, Errors e) { ValidationUtils.rejectIfEmpty(e,
							"name",
							"name.empty"); Person p = (Person) obj;
							if(p.getAge() <
							0) { e.rejectValue(
							"age",
							"negativevalue"); }
							else
							if(p.getAge() >
							110) { e.rejectValue(
							"age",
							"too.darn.old"); } } }

As you can see, the static rejectIfEmpty(..)method on the ValidationUtilsclass is used to reject the 'name'property if it is nullor the empty string. Have a look at the ValidationUtilsjavadocs to see what functionality it provides besides the example shown previously.

While it is certainly possible to implement a single Validatorclass to validate each of the nested objects in a rich object, it may be better to encapsulate the validation logic for each nested class of object in its own Validatorimplementation. A simple example of a 'rich'object would be a Customerthat is composed of two Stringproperties (a first and second name) and a complex Addressobject. Addressobjects may be used independently of Customerobjects, and so a distinct AddressValidatorhas been implemented. If you want your CustomerValidatorto reuse the logic contained within the AddressValidatorclass without resorting to copy-and-paste, you can dependency-inject or instantiate an AddressValidatorwithin your CustomerValidator, and use it like so:

							public
							classCustomerValidator
							implementsValidator {
							private
							finalValidator addressValidator;
							publicCustomerValidator(Validator addressValidator) {
							if(addressValidator == null) {
							throw
							newIllegalArgumentException(
							"The supplied [Validator] is "+
							"required and must not be null."); }
							if(!addressValidator.supports(Address.
							class)) {
							throw
							newIllegalArgumentException(
							"The supplied [Validator] must "+
							"support the validation of [Address] instances."); }
							this.addressValidator = addressValidator; }
							/** * This Validator validates Customer instances, and any subclasses of Customer too */
							public
							booleansupports(Class clazz) {
							returnCustomer.
							class.isAssignableFrom(clazz); }
							public
							voidvalidate(Object target, Errors errors) { ValidationUtils.rejectIfEmptyOrWhitespace(errors,
							"firstName",
							"field.required"); ValidationUtils.rejectIfEmptyOrWhitespace(errors,
							"surname",
							"field.required"); Customer customer = (Customer) target;
							try{ errors.pushNestedPath(
							"address"); ValidationUtils.invokeValidator(
							this.addressValidator, customer.getAddress(), errors); }
							finally{ errors.popNestedPath(); } } }

Validation errors are reported to the Errorsobject passed to the validator. In case of Spring Web MVC you can use <spring:bind/>tag to inspect the error messages, but of course you can also inspect the errors object yourself. More information about the methods it offers can be found in the javadocs.

9.3 Resolving codes to error messages

We’ve talked about databinding and validation. Outputting messages corresponding to validation errors is the last thing we need to discuss. In the example we’ve shown above, we rejected the nameand the agefield. If we’re going to output the error messages by using a MessageSource, we will do so using the error code we’ve given when rejecting the field ('name' and 'age' in this case). When you call (either directly, or indirectly, using for example the ValidationUtilsclass) rejectValueor one of the other rejectmethods from the Errorsinterface, the underlying implementation will not only register the code you’ve passed in, but also a number of additional error codes. What error codes it registers is determined by the MessageCodesResolverthat is used. By default, the DefaultMessageCodesResolveris used, which for example not only registers a message with the code you gave, but also messages that include the field name you passed to the reject method. So in case you reject a field using rejectValue("age", "too.darn.old"), apart from the too.darn.oldcode, Spring will also register too.darn.old.ageand too.darn.old.age.int(so the first will include the field name and the second will include the type of the field); this is done as a convenience to aid developers in targeting error messages and suchlike.

More information on the MessageCodesResolverand the default strategy can be found online in the javadocs of MessageCodesResolverand DefaultMessageCodesResolver, respectively.

9.4 Bean manipulation and the BeanWrapper

The org.springframework.beanspackage adheres to the JavaBeans standard provided by Oracle. A JavaBean is simply a class with a default no-argument constructor, which follows a naming convention where (by way of an example) a property named bingoMadnesswould have a setter method setBingoMadness(..)and a getter method getBingoMadness(). For more information about JavaBeans and the specification, please refer to Oracle’s website ( javabeans).

One quite important class in the beans package is the BeanWrapperinterface and its corresponding implementation ( BeanWrapperImpl). As quoted from the javadocs, the BeanWrapperoffers functionality to set and get property values (individually or in bulk), get property descriptors, and to query properties to determine if they are readable or writable. Also, the BeanWrapperoffers support for nested properties, enabling the setting of properties on sub-properties to an unlimited depth. Then, the BeanWrappersupports the ability to add standard JavaBeans PropertyChangeListenersand VetoableChangeListeners, without the need for supporting code in the target class. Last but not least, the BeanWrapperprovides support for the setting of indexed properties. The BeanWrapperusually isn’t used by application code directly, but by the DataBinderand the BeanFactory.

The way the BeanWrapperworks is partly indicated by its name: it wraps a beanto perform actions on that bean, like setting and retrieving properties.

9.4.1 Setting and getting basic and nested properties

Setting and getting properties is done using the setPropertyValue(s)and getPropertyValue(s)methods that both come with a couple of overloaded variants. They’re all described in more detail in the javadocs Spring comes with. What’s important to know is that there are a couple of conventions for indicating properties of an object. A couple of examples:

Table 9.1. Examples of properties

Expression Explanation

name

Indicates the property namecorresponding to the methods getName()or isName()and setName(..)

account.name

Indicates the nested property nameof the property accountcorresponding e.g. to the methods getAccount().setName()or getAccount().getName()

account[2]

Indicates the thirdelement of the indexed property account. Indexed properties can be of type array, listor other naturally orderedcollection

account[COMPANYNAME]

Indicates the value of the map entry indexed by the key COMPANYNAMEof the Map property account

Below you’ll find some examples of working with the BeanWrapperto get and set properties.

(This next section is not vitally important to you if you’re not planning to work with the BeanWrapperdirectly. If you’re just using the DataBinderand the BeanFactoryand their out-of-the-box implementation, you should skip ahead to the section about PropertyEditors.)

Consider the following two classes:

								public
								classCompany {
								privateString name;
								privateEmployee managingDirector;
								publicString getName() {
								return
								this.name; }
								public
								voidsetName(String name) {
								this.name = name; }
								publicEmployee getManagingDirector() {
								return
								this.managingDirector; }
								public
								voidsetManagingDirector(Employee managingDirector) {
								this.managingDirector = managingDirector; } }
								public
								classEmployee {
								privateString name;
								private
								floatsalary;
								publicString getName() {
								return
								this.name; }
								public
								voidsetName(String name) {
								this.name = name; }
								public
								floatgetSalary() {
								returnsalary; }
								public
								voidsetSalary(
								floatsalary) {
								this.salary = salary; } }

The following code snippets show some examples of how to retrieve and manipulate some of the properties of instantiated Companiesand Employees:

BeanWrapper company =
								newBeanWrapperImpl(
								newCompany());
								// setting the company name..company.setPropertyValue(
								"name",
								"Some Company Inc.");
								// ... can also be done like this:PropertyValue value =
								newPropertyValue(
								"name",
								"Some Company Inc."); company.setPropertyValue(value);
								// ok, let's create the director and tie it to the company:BeanWrapper jim =
								newBeanWrapperImpl(
								newEmployee()); jim.setPropertyValue(
								"name",
								"Jim Stravinsky"); company.setPropertyValue(
								"managingDirector", jim.getWrappedInstance());
								// retrieving the salary of the managingDirector through the companyFloat salary = (Float) company.getPropertyValue(
								"managingDirector.salary");

9.4.2 Built-in PropertyEditor implementations

Spring uses the concept of PropertyEditorsto effect the conversion between an Objectand a String. If you think about it, it sometimes might be handy to be able to represent properties in a different way than the object itself. For example, a Datecan be represented in a human readable way (as the String '2007-14-09'), while we’re still able to convert the human readable form back to the original date (or even better: convert any date entered in a human readable form, back to Dateobjects). This behavior can be achieved by registering custom editors, of type java.beans.PropertyEditor. Registering custom editors on a BeanWrapperor alternately in a specific IoC container as mentioned in the previous chapter, gives it the knowledge of how to convert properties to the desired type. Read more about PropertyEditorsin the javadocs of the java.beanspackage provided by Oracle.

A couple of examples where property editing is used in Spring:

  • setting properties on beansis done using PropertyEditors. When mentioning java.lang.Stringas the value of a property of some bean you’re declaring in XML file, Spring will (if the setter of the corresponding property has a Class-parameter) use the ClassEditorto try to resolve the parameter to a Classobject.
  • parsing HTTP request parametersin Spring’s MVC framework is done using all kinds of PropertyEditorsthat you can manually bind in all subclasses of the CommandController.

Spring has a number of built-in PropertyEditorsto make life easy. Each of those is listed below and they are all located in the org.springframework.beans.propertyeditorspackage. Most, but not all (as indicated below), are registered by default by BeanWrapperImpl. Where the property editor is configurable in some fashion, you can of course still register your own variant to override the default one:

Table 9.2. Built-in PropertyEditors

Class Explanation

ByteArrayPropertyEditor

Editor for byte arrays. Strings will simply be converted to their corresponding byte representations. Registered by default by BeanWrapperImpl.

ClassEditor

Parses Strings representing classes to actual classes and the other way around. When a class is not found, an IllegalArgumentExceptionis thrown. Registered by default by BeanWrapperImpl.

CustomBooleanEditor

Customizable property editor for Booleanproperties. Registered by default by BeanWrapperImpl, but, can be overridden by registering custom instance of it as custom editor.

CustomCollectionEditor

Property editor for Collections, converting any source Collectionto a given target Collectiontype.

CustomDateEditor

Customizable property editor for java.util.Date, supporting a custom DateFormat. NOT registered by default. Must be user registered as needed with appropriate format.

CustomNumberEditor

Customizable property editor for any Number subclass like Integer, Long, Float, Double. Registered by default by BeanWrapperImpl, but can be overridden by registering custom instance of it as a custom editor.

FileEditor

Capable of resolving Strings to java.io.Fileobjects. Registered by default by BeanWrapperImpl.

InputStreamEditor

One-way property editor, capable of taking a text string and producing (via an intermediate ResourceEditorand Resource) an InputStream, so InputStreamproperties may be directly set as Strings. Note that the default usage will not close the InputStreamfor you! Registered by default by BeanWrapperImpl.

LocaleEditor

Capable of resolving Strings to Localeobjects and vice versa (the String format is [country] [variant], which is the same thing the toString() method of Locale provides). Registered by default by BeanWrapperImpl.

PatternEditor

Capable of resolving Strings to java.util.regex.Patternobjects and vice versa.

PropertiesEditor

Capable of converting Strings (formatted using the format as defined in the javadocs of the java.util.Propertiesclass) to Propertiesobjects. Registered by default by BeanWrapperImpl.

StringTrimmerEditor

Property editor that trims Strings. Optionally allows transforming an empty string into a nullvalue. NOT registered by default; must be user registered as needed.

URLEditor

Capable of resolving a String representation of a URL to an actual URLobject. Registered by default by BeanWrapperImpl.

Spring uses the java.beans.PropertyEditorManagerto set the search path for property editors that might be needed. The search path also includes sun.bean.editors, which includes PropertyEditorimplementations for types such as Font, Color, and most of the primitive types. Note also that the standard JavaBeans infrastructure will automatically discover PropertyEditorclasses (without you having to register them explicitly) if they are in the same package as the class they handle, and have the same name as that class, with 'Editor'appended; for example, one could have the following class and package structure, which would be sufficient for the FooEditorclass to be recognized and used as the PropertyEditorfor Foo-typed properties.

com chank pop Foo FooEditor // the PropertyEditor for the Foo class

Note that you can also use the standard BeanInfoJavaBeans mechanism here as well (described in not-amazing-detail here). Find below an example of using the BeanInfomechanism for explicitly registering one or more PropertyEditorinstances with the properties of an associated class.

com chank pop Foo FooBeanInfo // the BeanInfo for the Foo class

Here is the Java source code for the referenced FooBeanInfoclass. This would associate a CustomNumberEditorwith the ageproperty of the Fooclass.

								public
								classFooBeanInfo
								extendsSimpleBeanInfo {
								publicPropertyDescriptor[] getPropertyDescriptors() {
								try{
								finalPropertyEditor numberPE =
								newCustomNumberEditor(Integer.
								class, true); PropertyDescriptor ageDescriptor =
								newPropertyDescriptor(
								"age", Foo.
								class) {
								publicPropertyEditor createPropertyEditor(Object bean) {
								returnnumberPE; }; };
								return
								newPropertyDescriptor[] { ageDescriptor }; }
								catch(IntrospectionException ex) {
								throw
								newError(ex.toString()); } } }

Registering additional custom PropertyEditors

When setting bean properties as a string value, a Spring IoC container ultimately uses standard JavaBeans PropertyEditorsto convert these Strings to the complex type of the property. Spring pre-registers a number of custom PropertyEditors(for example, to convert a classname expressed as a string into a real Classobject). Additionally, Java’s standard JavaBeans PropertyEditorlookup mechanism allows a PropertyEditorfor a class simply to be named appropriately and placed in the same package as the class it provides support for, to be found automatically.

If there is a need to register other custom PropertyEditors, there are several mechanisms available. The most manual approach, which is not normally convenient or recommended, is to simply use the registerCustomEditor()method of the ConfigurableBeanFactoryinterface, assuming you have a BeanFactoryreference. Another, slightly more convenient, mechanism is to use a special bean factory post-processor called CustomEditorConfigurer. Although bean factory post-processors can be used with BeanFactoryimplementations, the CustomEditorConfigurerhas a nested property setup, so it is strongly recommended that it is used with the ApplicationContext, where it may be deployed in similar fashion to any other bean, and automatically detected and applied.

Note that all bean factories and application contexts automatically use a number of built-in property editors, through their use of something called a BeanWrapperto handle property conversions. The standard property editors that the BeanWrapperregisters are listed in the previous section. Additionally, ApplicationContextsalso override or add an additional number of editors to handle resource lookups in a manner appropriate to the specific application context type.

Standard JavaBeans PropertyEditorinstances are used to convert property values expressed as strings to the actual complex type of the property. CustomEditorConfigurer, a bean factory post-processor, may be used to conveniently add support for additional PropertyEditorinstances to an ApplicationContext.

Consider a user class ExoticType, and another class DependsOnExoticTypewhich needs ExoticTypeset as a property:

									packageexample;
									public
									classExoticType {
									privateString name;
									publicExoticType(String name) {
									this.name = name; } }
									public
									classDependsOnExoticType {
									privateExoticType type;
									public
									voidsetType(ExoticType type) {
									this.type = type; } }

When things are properly set up, we want to be able to assign the type property as a string, which a PropertyEditorwill behind the scenes convert into an actual ExoticTypeinstance:

									<bean
									id=
									"sample"
									class=
									"example.DependsOnExoticType"
									>
									<property
									name=
									"type"
									value=
									"aNameForExoticType"
									/>
									</bean>

The PropertyEditorimplementation could look similar to this:

									// converts string representation to ExoticType object
									packageexample;
									public
									classExoticTypeEditor
									extendsPropertyEditorSupport {
									public
									voidsetAsText(String text) { setValue(
									newExoticType(text.toUpperCase())); } }

Finally, we use CustomEditorConfigurerto register the new PropertyEditorwith the ApplicationContext, which will then be able to use it as needed:

									<bean
									class=
									"org.springframework.beans.factory.config.CustomEditorConfigurer"
									>
									<property
									name=
									"customEditors"
									>
									<map>
									<entry
									key=
									"example.ExoticType"
									value=
									"example.ExoticTypeEditor"
									/>
									</map>
									</property>
									</bean>
Using PropertyEditorRegistrars

Another mechanism for registering property editors with the Spring container is to create and use a PropertyEditorRegistrar. This interface is particularly useful when you need to use the same set of property editors in several different situations: write a corresponding registrar and reuse that in each case. PropertyEditorRegistrarswork in conjunction with an interface called PropertyEditorRegistry, an interface that is implemented by the Spring BeanWrapper(and DataBinder). PropertyEditorRegistrarsare particularly convenient when used in conjunction with the CustomEditorConfigurer(introduced here), which exposes a property called setPropertyEditorRegistrars(..): PropertyEditorRegistrarsadded to a CustomEditorConfigurerin this fashion can easily be shared with DataBinderand Spring MVC Controllers. Furthermore, it avoids the need for synchronization on custom editors: a PropertyEditorRegistraris expected to create fresh PropertyEditorinstances for each bean creation attempt.

Using a PropertyEditorRegistraris perhaps best illustrated with an example. First off, you need to create your own PropertyEditorRegistrarimplementation:

										packagecom.foo.editors.spring;
										public
										final
										classCustomPropertyEditorRegistrar
										implementsPropertyEditorRegistrar {
										public
										voidregisterCustomEditors(PropertyEditorRegistry registry) {
										// it is expected that new PropertyEditor instances are createdregistry.registerCustomEditor(ExoticType.
										class,
										newExoticTypeEditor());
										// you could register as many custom property editors as are required here...} }

See also the org.springframework.beans.support.ResourceEditorRegistrarfor an example PropertyEditorRegistrarimplementation. Notice how in its implementation of the registerCustomEditors(..)method it creates new instances of each property editor.

Next we configure a CustomEditorConfigurerand inject an instance of our CustomPropertyEditorRegistrarinto it:

										<bean
										class=
										"org.springframework.beans.factory.config.CustomEditorConfigurer"
										>
										<property
										name=
										"propertyEditorRegistrars"
										>
										<list>
										<ref
										bean=
										"customPropertyEditorRegistrar"
										/>
										</list>
										</property>
										</bean>
										<bean
										id=
										"customPropertyEditorRegistrar"
										class=
										"com.foo.editors.spring.CustomPropertyEditorRegistrar"
										/>

Finally, and in a bit of a departure from the focus of this chapter, for those of you using Spring’s MVC web framework, using PropertyEditorRegistrarsin conjunction with data-binding Controllers(such as SimpleFormController) can be very convenient. Find below an example of using a PropertyEditorRegistrarin the implementation of an initBinder(..)method:

										public
										final
										classRegisterUserController
										extendsSimpleFormController {
										private
										finalPropertyEditorRegistrar customPropertyEditorRegistrar;
										publicRegisterUserController(PropertyEditorRegistrar propertyEditorRegistrar) {
										this.customPropertyEditorRegistrar = propertyEditorRegistrar; }
										protected
										voidinitBinder(HttpServletRequest request, ServletRequestDataBinder binder)
										throwsException {
										
											this.customPropertyEditorRegistrar.registerCustomEditors(binder);}
										// other methods to do with registering a User}

This style of PropertyEditorregistration can lead to concise code (the implementation of initBinder(..)is just one line long!), and allows common PropertyEditorregistration code to be encapsulated in a class and then shared amongst as many Controllersas needed.

9.5 Spring Type Conversion

Spring 3 introduces a core.convertpackage that provides a general type conversion system. The system defines an SPI to implement type conversion logic, as well as an API to execute type conversions at runtime. Within a Spring container, this system can be used as an alternative to PropertyEditors to convert externalized bean property value strings to required property types. The public API may also be used anywhere in your application where type conversion is needed.

9.5.1 Converter SPI

The SPI to implement type conversion logic is simple and strongly typed:

								packageorg.springframework.core.convert.converter;
								public
								interfaceConverter<S, T> { T convert(S source); }

To create your own converter, simply implement the interface above. Parameterize Sas the type you are converting from, and Tas the type you are converting to. Such a converter can also be applied transparently if a collection or array of Sneeds to be converted to an array or collection of T, provided that a delegating array/collection converter has been registered as well (which DefaultConversionServicedoes by default).

For each call to convert(S), the source argument is guaranteed to be NOT null. Your Converter may throw any unchecked exception if conversion fails; specifically, an IllegalArgumentExceptionshould be thrown to report an invalid source value. Take care to ensure that your Converterimplementation is thread-safe.

Several converter implementations are provided in the core.convert.supportpackage as a convenience. These include converters from Strings to Numbers and other common types. Consider StringToIntegeras an example for a typical Converterimplementation:

								packageorg.springframework.core.convert.support;
								final
								classStringToInteger
								implementsConverter<String, Integer> {
								publicInteger convert(String source) {
								returnInteger.valueOf(source); } }

9.5.2 ConverterFactory

When you need to centralize the conversion logic for an entire class hierarchy, for example, when converting from String to java.lang.Enum objects, implement ConverterFactory:

								packageorg.springframework.core.convert.converter;
								public
								interfaceConverterFactory<S, R> { <T
								extendsR> Converter<S, T> getConverter(Class<T> targetType); }

Parameterize S to be the type you are converting from and R to be the base type defining the rangeof classes you can convert to. Then implement getConverter(Class<T>), where T is a subclass of R.

Consider the StringToEnumConverterFactory as an example:

								packageorg.springframework.core.convert.support;
								final
								classStringToEnumConverterFactory
								implementsConverterFactory<String, Enum> {
								public<T
								extendsEnum> Converter<String, T> getConverter(Class<T> targetType) {
								return
								newStringToEnumConverter(targetType); }
								private
								final
								classStringToEnumConverter<T
								extendsEnum>
								implementsConverter<String, T> {
								privateClass<T> enumType;
								publicStringToEnumConverter(Class<T> enumType) {
								this.enumType = enumType; }
								publicT convert(String source) {
								return(T) Enum.valueOf(
								this.enumType, source.trim()); } } }

9.5.3 GenericConverter

When you require a sophisticated Converter implementation, consider the GenericConverter interface. With a more flexible but less strongly typed signature, a GenericConverter supports converting between multiple source and target types. In addition, a GenericConverter makes available source and target field context you can use when implementing your conversion logic. Such context allows a type conversion to be driven by a field annotation, or generic information declared on a field signature.

								packageorg.springframework.core.convert.converter;
								public
								interfaceGenericConverter {
								publicSet<ConvertiblePair> getConvertibleTypes(); Object convert(Object source, TypeDescriptor sourceType, TypeDescriptor targetType); }

To implement a GenericConverter, have getConvertibleTypes() return the supported source→target type pairs. Then implement convert(Object, TypeDescriptor, TypeDescriptor) to implement your conversion logic. The source TypeDescriptor provides access to the source field holding the value being converted. The target TypeDescriptor provides access to the target field where the converted value will be set.

A good example of a GenericConverter is a converter that converts between a Java Array and a Collection. Such an ArrayToCollectionConverter introspects the field that declares the target Collection type to resolve the Collection’s element type. This allows each element in the source array to be converted to the Collection element type before the Collection is set on the target field.

[Note] Note

Because GenericConverter is a more complex SPI interface, only use it when you need it. Favor Converter or ConverterFactory for basic type conversion needs.

ConditionalGenericConverter

Sometimes you only want a Converterto execute if a specific condition holds true. For example, you might only want to execute a Converterif a specific annotation is present on the target field. Or you might only want to execute a Converterif a specific method, such as a static valueOfmethod, is defined on the target class. ConditionalGenericConverteris the union of the GenericConverterand ConditionalConverterinterfaces that allows you to define such custom matching criteria:

									public
									interfaceConditionalGenericConverter
									extendsGenericConverter, ConditionalConverter {
									booleanmatches(TypeDescriptor sourceType, TypeDescriptor targetType); }

A good example of a ConditionalGenericConverteris an EntityConverter that converts between an persistent entity identifier and an entity reference. Such a EntityConverter might only match if the target entity type declares a static finder method e.g. findAccount(Long). You would perform such a finder method check in the implementation of matches(TypeDescriptor, TypeDescriptor).

9.5.4 ConversionService API

The ConversionService defines a unified API for executing type conversion logic at runtime. Converters are often executed behind this facade interface:

								packageorg.springframework.core.convert;
								public
								interfaceConversionService {
								booleancanConvert(Class<?> sourceType, Class<?> targetType); <T> T convert(Object source, Class<T> targetType);
								booleancanConvert(TypeDescriptor sourceType, TypeDescriptor targetType); Object convert(Object source, TypeDescriptor sourceType, TypeDescriptor targetType); }

Most ConversionService implementations also implement ConverterRegistry, which provides an SPI for registering converters. Internally, a ConversionService implementation delegates to its registered converters to carry out type conversion logic.

A robust ConversionService implementation is provided in the core.convert.supportpackage. GenericConversionServiceis the general-purpose implementation suitable for use in most environments. ConversionServiceFactoryprovides a convenient factory for creating common ConversionService configurations.

9.5.5 Configuring a ConversionService

A ConversionService is a stateless object designed to be instantiated at application startup, then shared between multiple threads. In a Spring application, you typically configure a ConversionService instance per Spring container (or ApplicationContext). That ConversionService will be picked up by Spring and then used whenever a type conversion needs to be performed by the framework. You may also inject this ConversionService into any of your beans and invoke it directly.

[Note] Note

If no ConversionService is registered with Spring, the original PropertyEditor-based system is used.

To register a default ConversionService with Spring, add the following bean definition with id conversionService:

								<bean
								id=
								"conversionService"
								class=
								"org.springframework.context.support.ConversionServiceFactoryBean"
								/>

A default ConversionService can convert between strings, numbers, enums, collections, maps, and other common types. To supplement or override the default converters with your own custom converter(s), set the convertersproperty. Property values may implement either of the Converter, ConverterFactory, or GenericConverter interfaces.

								<bean
								id=
								"conversionService"
								class=
								"org.springframework.context.support.ConversionServiceFactoryBean"
								>
								<property
								name=
								"converters"
								>
								<set>
								<bean
								class=
								"example.MyCustomConverter"
								/>
								</set>
								</property>
								</bean>

It is also common to use a ConversionService within a Spring MVC application. See Section 22.16.3, “Conversion and Formatting”in the Spring MVC chapter.

In certain situations you may wish to apply formatting during conversion. See Section 9.6.3, “FormatterRegistry SPI”for details on using FormattingConversionServiceFactoryBean.

9.5.6 Using a ConversionService programmatically

To work with a ConversionService instance programmatically, simply inject a reference to it like you would for any other bean:

								
									@Service
								public
								classMyService {
								
									@Autowired
								publicMyService(ConversionService conversionService) {
								this.conversionService = conversionService; }
								public
								voiddoIt() {
								this.conversionService.convert(...) } }

For most use cases, the convertmethod specifying the targetTypecan be used but it will not work with more complex types such as a collection of a parameterized element. If you want to convert a Listof Integerto a Listof Stringprogrammatically, for instance, you need to provide a formal definition of the source and target types.

Fortunately, TypeDescriptorprovides various options to make that straightforward:

DefaultConversionService cs =
								newDefaultConversionService(); List<Integer> input = .... cs.convert(input, TypeDescriptor.forObject(input),
								// List<Integer> type descriptorTypeDescriptor.collection(List.
								class, TypeDescriptor.valueOf(String.
								class)));

Note that DefaultConversionServiceregisters converters automatically which are appropriate for most environments. This includes collection converters, scalar converters, and also basic Objectto Stringconverters. The same converters can be registered with any ConverterRegistryusing the static addDefaultConvertersmethod on the DefaultConversionServiceclass.

Converters for value types will be reused for arrays and collections, so there is no need to create a specific converter to convert from a Collectionof Sto a Collectionof T, assuming that standard collection handling is appropriate.

9.6 Spring Field Formatting

As discussed in the previous section, core.convertis a general-purpose type conversion system. It provides a unified ConversionService API as well as a strongly-typed Converter SPI for implementing conversion logic from one type to another. A Spring Container uses this system to bind bean property values. In addition, both the Spring Expression Language (SpEL) and DataBinder use this system to bind field values. For example, when SpEL needs to coerce a Shortto a Longto complete an expression.setValue(Object bean, Object value)attempt, the core.convert system performs the coercion.

Now consider the type conversion requirements of a typical client environment such as a web or desktop application. In such environments, you typically convert from Stringto support the client postback process, as well as back to Stringto support the view rendering process. In addition, you often need to localize String values. The more general core.convertConverter SPI does not address such formattingrequirements directly. To directly address them, Spring 3 introduces a convenient Formatter SPI that provides a simple and robust alternative to PropertyEditors for client environments.

In general, use the Converter SPI when you need to implement general-purpose type conversion logic; for example, for converting between a java.util.Date and and java.lang.Long. Use the Formatter SPI when you’re working in a client environment, such as a web application, and need to parse and print localized field values. The ConversionService provides a unified type conversion API for both SPIs.

9.6.1 Formatter SPI

The Formatter SPI to implement field formatting logic is simple and strongly typed:

								packageorg.springframework.format;
								public
								interfaceFormatter<T>
								extendsPrinter<T>, Parser<T> { }

Where Formatter extends from the Printer and Parser building-block interfaces:

								public
								interfacePrinter<T> { String print(T fieldValue, Locale locale); }
								importjava.text.ParseException;
								public
								interfaceParser<T> { T parse(String clientValue, Locale locale)
								throwsParseException; }

To create your own Formatter, simply implement the Formatter interface above. Parameterize T to be the type of object you wish to format, for example, java.util.Date. Implement the print()operation to print an instance of T for display in the client locale. Implement the parse()operation to parse an instance of T from the formatted representation returned from the client locale. Your Formatter should throw a ParseException or IllegalArgumentException if a parse attempt fails. Take care to ensure your Formatter implementation is thread-safe.

Several Formatter implementations are provided in formatsubpackages as a convenience. The numberpackage provides a NumberFormatter, CurrencyFormatter, and PercentFormatterto format java.lang.Numberobjects using a java.text.NumberFormat. The datetimepackage provides a DateFormatterto format java.util.Dateobjects with a java.text.DateFormat. The datetime.jodapackage provides comprehensive datetime formatting support based on the Joda Time library.

Consider DateFormatteras an example Formatterimplementation:

								packageorg.springframework.format.datetime;
								public
								final
								classDateFormatter
								implementsFormatter<Date> {
								privateString pattern;
								publicDateFormatter(String pattern) {
								this.pattern = pattern; }
								publicString print(Date date, Locale locale) {
								if(date == null) {
								return
								""; }
								returngetDateFormat(locale).format(date); }
								publicDate parse(String formatted, Locale locale)
								throwsParseException {
								if(formatted.length() ==
								0) {
								returnnull; }
								returngetDateFormat(locale).parse(formatted); }
								protectedDateFormat getDateFormat(Locale locale) { DateFormat dateFormat =
								newSimpleDateFormat(
								this.pattern, locale); dateFormat.setLenient(false);
								returndateFormat; } }

The Spring team welcomes community-driven Formattercontributions; see jira.spring.ioto contribute.

9.6.2 Annotation-driven Formatting

As you will see, field formatting can be configured by field type or annotation. To bind an Annotation to a formatter, implement AnnotationFormatterFactory:

								packageorg.springframework.format;
								public
								interfaceAnnotationFormatterFactory<A
								extendsAnnotation> { Set<Class<?>> getFieldTypes(); Printer<?> getPrinter(A annotation, Class<?> fieldType); Parser<?> getParser(A annotation, Class<?> fieldType); }

Parameterize A to be the field annotationType you wish to associate formatting logic with, for example org.springframework.format.annotation.DateTimeFormat. Have getFieldTypes()return the types of fields the annotation may be used on. Have getPrinter()return a Printer to print the value of an annotated field. Have getParser()return a Parser to parse a clientValue for an annotated field.

The example AnnotationFormatterFactory implementation below binds the @NumberFormat Annotation to a formatter. This annotation allows either a number style or pattern to be specified:

								public
								final
								classNumberFormatAnnotationFormatterFactory
								implementsAnnotationFormatterFactory<NumberFormat> {
								publicSet<Class<?>> getFieldTypes() {
								return
								newHashSet<Class<?>>(asList(
								newClass<?>[] { Short.
								class, Integer.
								class, Long.
								class, Float.
								class, Double.
								class, BigDecimal.
								class, BigInteger.
								class})); }
								publicPrinter<Number> getPrinter(NumberFormat annotation, Class<?> fieldType) {
								returnconfigureFormatterFrom(annotation, fieldType); }
								publicParser<Number> getParser(NumberFormat annotation, Class<?> fieldType) {
								returnconfigureFormatterFrom(annotation, fieldType); }
								privateFormatter<Number> configureFormatterFrom(NumberFormat annotation, Class<?> fieldType) {
								if(!annotation.pattern().isEmpty()) {
								return
								newNumberFormatter(annotation.pattern()); }
								else{ Style style = annotation.style();
								if(style == Style.PERCENT) {
								return
								newPercentFormatter(); }
								else
								if(style == Style.CURRENCY) {
								return
								newCurrencyFormatter(); }
								else{
								return
								newNumberFormatter(); } } } }

To trigger formatting, simply annotate fields with @NumberFormat:

								public
								classMyModel {
								
									@NumberFormat(style=Style.CURRENCY)
								privateBigDecimal decimal; }

Format Annotation API

A portable format annotation API exists in the org.springframework.format.annotationpackage. Use @NumberFormat to format java.lang.Number fields. Use @DateTimeFormat to format java.util.Date, java.util.Calendar, java.util.Long, or Joda Time fields.

The example below uses @DateTimeFormat to format a java.util.Date as a ISO Date (yyyy-MM-dd):

									public
									classMyModel {
									
										@DateTimeFormat(iso=ISO.DATE)
									privateDate date; }

9.6.3 FormatterRegistry SPI

The FormatterRegistry is an SPI for registering formatters and converters. FormattingConversionServiceis an implementation of FormatterRegistry suitable for most environments. This implementation may be configured programmatically or declaratively as a Spring bean using FormattingConversionServiceFactoryBean. Because this implementation also implements ConversionService, it can be directly configured for use with Spring’s DataBinder and the Spring Expression Language (SpEL).

Review the FormatterRegistry SPI below:

								packageorg.springframework.format;
								public
								interfaceFormatterRegistry
								extendsConverterRegistry {
								voidaddFormatterForFieldType(Class<?> fieldType, Printer<?> printer, Parser<?> parser);
								voidaddFormatterForFieldType(Class<?> fieldType, Formatter<?> formatter);
								voidaddFormatterForFieldType(Formatter<?> formatter);
								voidaddFormatterForAnnotation(AnnotationFormatterFactory<?, ?> factory); }

As shown above, Formatters can be registered by fieldType or annotation.

The FormatterRegistry SPI allows you to configure Formatting rules centrally, instead of duplicating such configuration across your Controllers. For example, you might want to enforce that all Date fields are formatted a certain way, or fields with a specific annotation are formatted in a certain way. With a shared FormatterRegistry, you define these rules once and they are applied whenever formatting is needed.

9.6.4 FormatterRegistrar SPI

The FormatterRegistrar is an SPI for registering formatters and converters through the FormatterRegistry:

								packageorg.springframework.format;
								public
								interfaceFormatterRegistrar {
								voidregisterFormatters(FormatterRegistry registry); }

A FormatterRegistrar is useful when registering multiple related converters and formatters for a given formatting category, such as Date formatting. It can also be useful where declarative registration is insufficient. For example when a formatter needs to be indexed under a specific field type different from its own <T> or when registering a Printer/Parser pair. The next section provides more information on converter and formatter registration.

9.6.5 Configuring Formatting in Spring MVC

See Section 22.16.3, “Conversion and Formatting”in the Spring MVC chapter.

9.7 Configuring a global date & time format

By default, date and time fields that are not annotated with @DateTimeFormatare converted from strings using the DateFormat.SHORTstyle. If you prefer, you can change this by defining your own global format.

You will need to ensure that Spring does not register default formatters, and instead you should register all formatters manually. Use the org.springframework.format.datetime.joda.JodaTimeFormatterRegistraror org.springframework.format.datetime.DateFormatterRegistrarclass depending on whether you use the Joda Time library.

For example, the following Java configuration will register a global ' `yyyyMMdd’ format. This example does not depend on the Joda Time library:

							
								@Configuration
							public
							classAppConfig {
							
								@Bean
							publicFormattingConversionService conversionService() {
							// Use the DefaultFormattingConversionService but do not register defaultsDefaultFormattingConversionService conversionService =
							newDefaultFormattingConversionService(false);
							// Ensure @NumberFormat is still supportedconversionService.addFormatterForFieldAnnotation(
							newNumberFormatAnnotationFormatterFactory());
							// Register date conversion with a specific global formatDateFormatterRegistrar registrar =
							newDateFormatterRegistrar(); registrar.setFormatter(
							newDateFormatter(
							"yyyyMMdd")); registrar.registerFormatters(conversionService);
							returnconversionService; } }

If you prefer XML based configuration you can use a FormattingConversionServiceFactoryBean. Here is the same example, this time using Joda Time:

							<?xml version="1.0" encoding="UTF-8"?>
							<beans
							xmlns=
							"http://www.springframework.org/schema/beans"
							xmlns:xsi=
							"http://www.w3.org/2001/XMLSchema-instance"
							xsi:schemaLocation=
							" http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd> <bean id="
							conversionService"
							class=
							"org.springframework.format.support.FormattingConversionServiceFactoryBean"
							>
							<property
							name=
							"registerDefaultFormatters"
							value=
							"false"
							/>
							<property
							name=
							"formatters"
							>
							<set>
							<bean
							class=
							"org.springframework.format.number.NumberFormatAnnotationFormatterFactory"
							/>
							</set>
							</property>
							<property
							name=
							"formatterRegistrars"
							>
							<set>
							<bean
							class=
							"org.springframework.format.datetime.joda.JodaTimeFormatterRegistrar"
							>
							<property
							name=
							"dateFormatter"
							>
							<bean
							class=
							"org.springframework.format.datetime.joda.DateTimeFormatterFactoryBean"
							>
							<property
							name=
							"pattern"
							value=
							"yyyyMMdd"
							/>
							</bean>
							</property>
							</bean>
							</set>
							</property>
							</bean>
							</beans>
[Note] Note

Joda Time provides separate distinct types to represent date, timeand date-timevalues. The dateFormatter, timeFormatterand dateTimeFormatterproperties of the JodaTimeFormatterRegistrarshould be used to configure the different formats for each type. The DateTimeFormatterFactoryBeanprovides a convenient way to create formatters.

If you are using Spring MVC remember to explicitly configure the conversion service that is used. For Java based @Configurationthis means extending the WebMvcConfigurationSupportclass and overriding the mvcConversionService()method. For XML you should use the 'conversion-service'attribute of the mvc:annotation-drivenelement. See Section 22.16.3, “Conversion and Formatting”for details.

9.8 Spring Validation

Spring 3 introduces several enhancements to its validation support. First, the JSR-303 Bean Validation API is now fully supported. Second, when used programmatically, Spring’s DataBinder can now validate objects as well as bind to them. Third, Spring MVC now has support for declaratively validating @Controllerinputs.

9.8.1 Overview of the JSR-303 Bean Validation API

JSR-303 standardizes validation constraint declaration and metadata for the Java platform. Using this API, you annotate domain model properties with declarative validation constraints and the runtime enforces them. There are a number of built-in constraints you can take advantage of. You may also define your own custom constraints.

To illustrate, consider a simple PersonForm model with two properties:

								public
								classPersonForm {
								privateString name;
								private
								intage; }

JSR-303 allows you to define declarative validation constraints against such properties:

								public
								classPersonForm {
								
									@NotNull
								
									@Size(max=64)
								privateString name;
								
									@Min(0)
								private
								intage; }

When an instance of this class is validated by a JSR-303 Validator, these constraints will be enforced.

For general information on JSR-303/JSR-349, see the Bean Validation website. For information on the specific capabilities of the default reference implementation, see the Hibernate Validatordocumentation. To learn how to setup a Bean Validation provider as a Spring bean, keep reading.

9.8.2 Configuring a Bean Validation Provider

Spring provides full support for the Bean Validation API. This includes convenient support for bootstrapping a JSR-303/JSR-349 Bean Validation provider as a Spring bean. This allows for a javax.validation.ValidatorFactoryor javax.validation.Validatorto be injected wherever validation is needed in your application.

Use the LocalValidatorFactoryBeanto configure a default Validator as a Spring bean:

								<bean
								id=
								"validator"
								class=
								"org.springframework.validation.beanvalidation.LocalValidatorFactoryBean"
								/>

The basic configuration above will trigger Bean Validation to initialize using its default bootstrap mechanism. A JSR-303/JSR-349 provider, such as Hibernate Validator, is expected to be present in the classpath and will be detected automatically.

Injecting a Validator

LocalValidatorFactoryBeanimplements both javax.validation.ValidatorFactoryand javax.validation.Validator, as well as Spring’s org.springframework.validation.Validator. You may inject a reference to either of these interfaces into beans that need to invoke validation logic.

Inject a reference to javax.validation.Validatorif you prefer to work with the Bean Validation API directly:

									importjavax.validation.Validator;
									
										@Service
									public
									classMyService {
									
										@Autowired
									privateValidator validator;

Inject a reference to org.springframework.validation.Validatorif your bean requires the Spring Validation API:

									importorg.springframework.validation.Validator;
									
										@Service
									public
									classMyService {
									
										@Autowired
									privateValidator validator; }

Configuring Custom Constraints

Each Bean Validation constraint consists of two parts. First, a @Constraintannotation that declares the constraint and its configurable properties. Second, an implementation of the javax.validation.ConstraintValidatorinterface that implements the constraint’s behavior. To associate a declaration with an implementation, each @Constraintannotation references a corresponding ValidationConstraint implementation class. At runtime, a ConstraintValidatorFactoryinstantiates the referenced implementation when the constraint annotation is encountered in your domain model.

By default, the LocalValidatorFactoryBeanconfigures a SpringConstraintValidatorFactorythat uses Spring to create ConstraintValidator instances. This allows your custom ConstraintValidators to benefit from dependency injection like any other Spring bean.

Shown below is an example of a custom @Constraintdeclaration, followed by an associated ConstraintValidatorimplementation that uses Spring for dependency injection:

									
										@Target({ElementType.METHOD, ElementType.FIELD})
									
										@Retention(RetentionPolicy.RUNTIME)
									
										@Constraint(validatedBy=MyConstraintValidator.class)
									public
									
										@interfaceMyConstraint { }
									importjavax.validation.ConstraintValidator;
									public
									classMyConstraintValidator
									implementsConstraintValidator {
									
										@Autowired;
									privateFoo aDependency; ... }

As you can see, a ConstraintValidator implementation may have its dependencies @Autowired like any other Spring bean.

Spring-driven Method Validation

The method validation feature supported by Bean Validation 1.1, and as a custom extension also by Hibernate Validator 4.3, can be integrated into a Spring context through a MethodValidationPostProcessorbean definition:

									<bean
									class=
									"org.springframework.validation.beanvalidation.MethodValidationPostProcessor"
									/>

In order to be eligible for Spring-driven method validation, all target classes need to be annotated with Spring’s @Validatedannotation, optionally declaring the validation groups to use. Check out the MethodValidationPostProcessorjavadocs for setup details with Hibernate Validator and Bean Validation 1.1 providers.

Additional Configuration Options

The default LocalValidatorFactoryBeanconfiguration should prove sufficient for most cases. There are a number of configuration options for various Bean Validation constructs, from message interpolation to traversal resolution. See the LocalValidatorFactoryBeanjavadocs for more information on these options.

9.8.3 Configuring a DataBinder

Since Spring 3, a DataBinder instance can be configured with a Validator. Once configured, the Validator may be invoked by calling binder.validate(). Any validation Errors are automatically added to the binder’s BindingResult.

When working with the DataBinder programmatically, this can be used to invoke validation logic after binding to a target object:

Foo target =
								newFoo(); DataBinder binder =
								newDataBinder(target); binder.setValidator(
								newFooValidator());
								// bind to the target objectbinder.bind(propertyValues);
								// validate the target objectbinder.validate();
								// get BindingResult that includes any validation errorsBindingResult results = binder.getBindingResult();

A DataBinder can also be configured with multiple Validatorinstances via dataBinder.addValidatorsand dataBinder.replaceValidators. This is useful when combining globally configured Bean Validation with a Spring Validatorconfigured locally on a DataBinder instance. See ???.

9.8.4 Spring MVC 3 Validation

See Section 22.16.4, “Validation”in the Spring MVC chapter.

10. Spring Expression Language (SpEL)

10.1 Introduction

The Spring Expression Language (SpEL for short) is a powerful expression language that supports querying and manipulating an object graph at runtime. The language syntax is similar to Unified EL but offers additional features, most notably method invocation and basic string templating functionality.

While there are several other Java expression languages available, OGNL, MVEL, and JBoss EL, to name a few, the Spring Expression Language was created to provide the Spring community with a single well supported expression language that can be used across all the products in the Spring portfolio. Its language features are driven by the requirements of the projects in the Spring portfolio, including tooling requirements for code completion support within the eclipse based Spring Tool Suite. That said, SpEL is based on a technology agnostic API allowing other expression language implementations to be integrated should the need arise.

While SpEL serves as the foundation for expression evaluation within the Spring portfolio, it is not directly tied to Spring and can be used independently. In order to be self contained, many of the examples in this chapter use SpEL as if it were an independent expression language. This requires creating a few bootstrapping infrastructure classes such as the parser. Most Spring users will not need to deal with this infrastructure and will instead only author expression strings for evaluation. An example of this typical use is the integration of SpEL into creating XML or annotated based bean definitions as shown in the section Expression support for defining bean definitions.

This chapter covers the features of the expression language, its API, and its language syntax. In several places an Inventor and Inventor’s Society class are used as the target objects for expression evaluation. These class declarations and the data used to populate them are listed at the end of the chapter.

10.2 Feature Overview

The expression language supports the following functionality

  • Literal expressions
  • Boolean and relational operators
  • Regular expressions
  • Class expressions
  • Accessing properties, arrays, lists, maps
  • Method invocation
  • Relational operators
  • Assignment
  • Calling constructors
  • Bean references
  • Array construction
  • Inline lists
  • Inline maps
  • Ternary operator
  • Variables
  • User defined functions
  • Collection projection
  • Collection selection
  • Templated expressions

10.3 Expression Evaluation using Spring’s Expression Interface

This section introduces the simple use of SpEL interfaces and its expression language. The complete language reference can be found in the section Language Reference.

The following code introduces the SpEL API to evaluate the literal string expression 'Hello World'.

ExpressionParser parser =
							newSpelExpressionParser(); Expression exp = parser.parseExpression(
							"
							
								'Hello World'
							");String message = (String) exp.getValue();

The value of the message variable is simply 'Hello World'.

The SpEL classes and interfaces you are most likely to use are located in the packages org.springframework.expressionand its sub packages and spel.support.

The interface ExpressionParseris responsible for parsing an expression string. In this example the expression string is a string literal denoted by the surrounding single quotes. The interface Expressionis responsible for evaluating the previously defined expression string. There are two exceptions that can be thrown, ParseExceptionand EvaluationExceptionwhen calling parser.parseExpressionand exp.getValuerespectively.

SpEL supports a wide range of features, such as calling methods, accessing properties, and calling constructors.

As an example of method invocation, we call the concatmethod on the string literal.

ExpressionParser parser =
							newSpelExpressionParser(); Expression exp = parser.parseExpression(
							"
							
								'Hello World'.concat('!')
							");String message = (String) exp.getValue();

The value of message is now 'Hello World!'.

As an example of calling a JavaBean property, the String property Bytescan be called as shown below.

ExpressionParser parser =
							newSpelExpressionParser();
							// invokes 'getBytes()'Expression exp = parser.parseExpression(
							"
							
								'Hello World'.bytes
							");
							byte[] bytes = (
							byte[]) exp.getValue();

SpEL also supports nested properties using standard dotnotation, i.e. prop1.prop2.prop3 and the setting of property values

Public fields may also be accessed.

ExpressionParser parser =
							newSpelExpressionParser();
							// invokes 'getBytes().length'Expression exp = parser.parseExpression(
							"
							
								'Hello World'.bytes.length
							");
							intlength = (Integer) exp.getValue();

The String’s constructor can be called instead of using a string literal.

ExpressionParser parser =
							newSpelExpressionParser(); Expression exp = parser.parseExpression(
							"
							
								new String('hello world').toUpperCase()
							");String message = exp.getValue(String.
							class);

Note the use of the generic method public <T> T getValue(Class<T> desiredResultType). Using this method removes the need to cast the value of the expression to the desired result type. An EvaluationExceptionwill be thrown if the value cannot be cast to the type Tor converted using the registered type converter.

The more common usage of SpEL is to provide an expression string that is evaluated against a specific object instance (called the root object). There are two options here and which to choose depends on whether the object against which the expression is being evaluated will be changing with each call to evaluate the expression. In the following example we retrieve the nameproperty from an instance of the Inventor class.

							// Create and set a calendarGregorianCalendar c =
							newGregorianCalendar(); c.set(
							1856,
							7,
							9);
							// The constructor arguments are name, birthday, and nationality.Inventor tesla =
							newInventor(
							"Nikola Tesla", c.getTime(),
							"Serbian"); ExpressionParser parser =
							newSpelExpressionParser(); Expression exp = parser.parseExpression(
							"
							
								name
							");EvaluationContext context =
							newStandardEvaluationContext(tesla); String name = (String) exp.getValue(context);

In the last line, the value of the string variable namewill be set to "Nikola Tesla". The class StandardEvaluationContext is where you can specify which object the "name" property will be evaluated against. This is the mechanism to use if the root object is unlikely to change, it can simply be set once in the evaluation context. If the root object is likely to change repeatedly, it can be supplied on each call to getValue, as this next example shows:

/ Create and set a calendar GregorianCalendar c =
							newGregorianCalendar(); c.set(
							1856,
							7,
							9);
							// The constructor arguments are name, birthday, and nationality.Inventor tesla =
							newInventor(
							"Nikola Tesla", c.getTime(),
							"Serbian"); ExpressionParser parser =
							newSpelExpressionParser(); Expression exp = parser.parseExpression(
							"
							
								name
							");String name = (String) exp.getValue(tesla);

In this case the inventor teslahas been supplied directly to getValueand the expression evaluation infrastructure creates and manages a default evaluation context internally - it did not require one to be supplied.

The StandardEvaluationContext is relatively expensive to construct and during repeated usage it builds up cached state that enables subsequent expression evaluations to be performed more quickly. For this reason it is better to cache and reuse them where possible, rather than construct a new one for each expression evaluation.

In some cases it can be desirable to use a configured evaluation context and yet still supply a different root object on each call to getValue. getValueallows both to be specified on the same call. In these situations the root object passed on the call is considered to override any (which maybe null) specified on the evaluation context.

[Note] Note

In standalone usage of SpEL there is a need to create the parser, parse expressions and perhaps provide evaluation contexts and a root context object. However, more common usage is to provide only the SpEL expression string as part of a configuration file, for example for Spring bean or Spring Web Flow definitions. In this case, the parser, evaluation context, root object and any predefined variables are all set up implicitly, requiring the user to specify nothing other than the expressions.

As a final introductory example, the use of a boolean operator is shown using the Inventor object in the previous example.

Expression exp = parser.parseExpression(
							"name == 'Nikola Tesla'");
							booleanresult = exp.getValue(context, Boolean.
							class);
							// evaluates to true

10.3.1 The EvaluationContext interface

The interface EvaluationContextis used when evaluating an expression to resolve properties, methods, fields, and to help perform type conversion. The out-of-the-box implementation, StandardEvaluationContext, uses reflection to manipulate the object, caching java.lang.reflect.Method, java.lang.reflect.Field, and java.lang.reflect.Constructorinstances for increased performance.

The StandardEvaluationContextis where you may specify the root object to evaluate against via the method setRootObject()or passing the root object into the constructor. You can also specify variables and functions that will be used in the expression using the methods setVariable()and registerFunction(). The use of variables and functions are described in the language reference sections Variablesand Functions. The StandardEvaluationContextis also where you can register custom ConstructorResolvers, MethodResolvers, and PropertyAccessors to extend how SpEL evaluates expressions. Please refer to the JavaDoc of these classes for more details.

Type Conversion

By default SpEL uses the conversion service available in Spring core ( org.springframework.core.convert.ConversionService). This conversion service comes with many converters built in for common conversions but is also fully extensible so custom conversions between types can be added. Additionally it has the key capability that it is generics aware. This means that when working with generic types in expressions, SpEL will attempt conversions to maintain type correctness for any objects it encounters.

What does this mean in practice? Suppose assignment, using setValue(), is being used to set a Listproperty. The type of the property is actually List<Boolean>. SpEL will recognize that the elements of the list need to be converted to Booleanbefore being placed in it. A simple example:

									classSimple {
									publicList<Boolean> booleanList =
									newArrayList<Boolean>(); } Simple simple =
									newSimple(); simple.booleanList.add(true); StandardEvaluationContext simpleContext =
									newStandardEvaluationContext(simple);
									// false is passed in here as a string. SpEL and the conversion service will
									// correctly recognize that it needs to be a Boolean and convert itparser.parseExpression(
									"booleanList[0]").setValue(simpleContext,
									"false");
									// b will be falseBoolean b = simple.booleanList.get(
									0);

10.3.2 Parser configuration

It is possible to configure the SpEL expression parser using a parser configuration object ( org.springframework.expression.spel.SpelParserConfiguration). The configuration object controls the behavior of some of the expression components. For example, if indexing into an array or collection and the element at the specified index is nullit is possible to automatically create the element. This is useful when using expressions made up of a chain of property references. If indexing into an array or list and specifying an index that is beyond the end of the current size of the array or list it is possible to automatically grow the array or list to accommodate that index.

								classDemo {
								publicList<String> list; }
								// Turn on:
								// - auto null reference initialization
								// - auto collection growingSpelParserConfiguration config =
								newSpelParserConfiguration(true,true); ExpressionParser parser =
								newSpelExpressionParser(config); Expression expression = parser.parseExpression(
								"list[3]"); Demo demo =
								newDemo(); Object o = expression.getValue(demo);
								// demo.list will now be a real collection of 4 entries
								// Each entry is a new empty String

It is also possible to configure the behaviour of the SpEL expression compiler.

10.3.3 SpEL compilation

Spring Framework 4.1 includes a basic expression compiler. Expressions are usually interpreted which provides a lot of dynamic flexibility during evaluation but does not provide the optimum performance. For occasional expression usage this is fine, but when used by other components like Spring Integration, performance can be very important and there is no real need for the dynamism.

The new SpEL compiler is intended to address this need. The compiler will generate a real Java class on the fly during evaluation that embodies the expression behavior and use that to achieve much faster expression evaluation. Due to the lack of typing around expressions the compiler uses information gathered during the interpreted evaluations of an expression when performing compilation. For example, it does not know the type of a property reference purely from the expression but during the first interpreted evaluation it will find out what it is. Of course, basing the compilation on this information could cause trouble later if the types of the various expression elements change over time. For this reason compilation is best suited to expressions whose type information is not going to change on repeated evaluations.

For a basic expression like this:

someArray[0].someProperty.someOtherProperty < 0.1

which involves array access, some property derefencing and numeric operations, the performance gain can be very noticeable. In an example micro benchmark run of 50000 iterations, it was taking 75ms to evaluate using only the interpreter and just 3ms using the compiled version of the expression.

Compiler configuration

The compiler is not turned on by default, but there are two ways to turn it on. It can be turned on using the parser configuration process discussed earlier or via a system property when SpEL usage is embedded inside another component. This section discusses both of these options.

Is is important to understand that there are a few modes the compiler can operate in, captured in an enum ( org.springframework.expression.spel.SpelCompilerMode). The modes are as follows:

  • OFF- The compiler is switched off; this is the default.
  • IMMEDIATE- In immediate mode the expressions are compiled as soon as possible. This is typically after the first interpreted evaluation. If the compiled expression fails (typically due to a type changing, as described above) then the caller of the expression evaluation will receive an exception.
  • MIXED- In mixed mode the expressions silently switch between interpreted and compiled mode over time. After some number of interpreted runs they will switch to compiled form and if something goes wrong with the compiled form (like a type changing, as described above) then the expression will automatically switch back to interpreted form again. Sometime later it may generate another compiled form and switch to it. Basically the exception that the user gets in IMMEDIATEmode is instead handled internally.

IMMEDIATEmode exists because MIXEDmode could cause issues for expressions that have side effects. If a compiled expression blows up after partially succeeding it may have already done something that has affected the state of the system. If this has happened the caller may not want it to silently re-run in interpreted mode since part of the expression may be running twice.

After selecting a mode, use the SpelParserConfigurationto configure the parser:

SpelParserConfiguration config =
									newSpelParserConfiguration(SpelCompilerMode.IMMEDIATE,
									this.getClass().getClassLoader()); SpelExpressionParser parser =
									newSpelExpressionParser(config); Expression expr = parser.parseExpression(
									"payload"); MyMessage message =
									newMyMessage(); Object payload = expr.getValue(message);

When specifying the compiler mode it is also possible to specify a classloader (passing null is allowed). Compiled expressions will be defined in a child classloader created under any that is supplied. It is important to ensure if a classloader is specified it can see all the types involved in the expression evaluation process. If none is specified then a default classloader will be used (typically the context classloader for the thread that is running during expression evaluation).

The second way to configure the compiler is for use when SpEL is embedded inside some other component and it may not be possible to configure via a configuration object. In these cases it is possible to use a system property. The property spring.expression.compiler.modecan be set to one of the SpelCompilerModeenum values ( off, immediate, or mixed).

Compiler limitations

With Spring Framework 4.1 the basic compilation framework is in place. However, the framework does not yet support compiling every kind of expression. The initial focus has been on the common expressions that are likely to be used in performance critical contexts. These kinds of expression cannot be compiled at the moment:

  • expressions involving assignment
  • expressions relying on the conversion service
  • expressions using custom resolvers or accessors
  • expressions using selection or projection

More and more types of expression will be compilable in the future.

10.4 Expression support for defining bean definitions

SpEL expressions can be used with XML or annotation-based configuration metadata for defining BeanDefinitions. In both cases the syntax to define the expression is of the form #{ <expression string> }.

10.4.1 XML based configuration

A property or constructor-arg value can be set using expressions as shown below.

								<bean
								id=
								"numberGuess"
								class=
								"org.spring.samples.NumberGuess"
								>
								<property
								name=
								"randomNumber"
								value=
								"#{ T(java.lang.Math).random() * 100.0 }"
								/>
								<!-- other properties -->
								</bean>

The variable systemPropertiesis predefined, so you can use it in your expressions as shown below. Note that you do not have to prefix the predefined variable with the #symbol in this context.

								<bean
								id=
								"taxCalculator"
								class=
								"org.spring.samples.TaxCalculator"
								>
								<property
								name=
								"defaultLocale"
								value=
								"#{ systemProperties['user.region'] }"
								/>
								<!-- other properties -->
								</bean>

You can also refer to other bean properties by name, for example.

								<bean
								id=
								"numberGuess"
								class=
								"org.spring.samples.NumberGuess"
								>
								<property
								name=
								"randomNumber"
								value=
								"#{ T(java.lang.Math).random() * 100.0 }"
								/>
								<!-- other properties -->
								</bean>
								<bean
								id=
								"shapeGuess"
								class=
								"org.spring.samples.ShapeGuess"
								>
								<property
								name=
								"initialShapeSeed"
								value=
								"#{ numberGuess.randomNumber }"
								/>
								<!-- other properties -->
								</bean>

10.4.2 Annotation-based configuration

The @Valueannotation can be placed on fields, methods and method/constructor parameters to specify a default value.

Here is an example to set the default value of a field variable.

								public
								static
								classFieldValueTestBean
								
									@Value("#{ systemProperties['user.region'] }")
								privateString defaultLocale;
								public
								voidsetDefaultLocale(String defaultLocale) {
								this.defaultLocale = defaultLocale; }
								publicString getDefaultLocale() {
								return
								this.defaultLocale; } }

The equivalent but on a property setter method is shown below.

								public
								static
								classPropertyValueTestBean
								privateString defaultLocale;
								
									@Value("#{ systemProperties['user.region'] }")
								public
								voidsetDefaultLocale(String defaultLocale) {
								this.defaultLocale = defaultLocale; }
								publicString getDefaultLocale() {
								return
								this.defaultLocale; } }

Autowired methods and constructors can also use the @Valueannotation.

								public
								classSimpleMovieLister {
								privateMovieFinder movieFinder;
								privateString defaultLocale;
								
									@Autowired
								public
								voidconfigure(MovieFinder movieFinder,
								
									@Value("#{ systemProperties['user.region'] }")String defaultLocale) {
								this.movieFinder = movieFinder;
								this.defaultLocale = defaultLocale; }
								// ...}
								public
								classMovieRecommender {
								privateString defaultLocale;
								privateCustomerPreferenceDao customerPreferenceDao;
								
									@Autowired
								publicMovieRecommender(CustomerPreferenceDao customerPreferenceDao,
								
									@Value("#{systemProperties['user.country']}")String defaultLocale) {
								this.customerPreferenceDao = customerPreferenceDao;
								this.defaultLocale = defaultLocale; }
								// ...}

10.5 Language Reference

10.5.1 Literal expressions

The types of literal expressions supported are strings, dates, numeric values (int, real, and hex), boolean and null. Strings are delimited by single quotes. To put a single quote itself in a string use two single quote characters. The following listing shows simple usage of literals. Typically they would not be used in isolation like this, but as part of a more complex expression, for example using a literal on one side of a logical comparison operator.

ExpressionParser parser =
								newSpelExpressionParser();
								// evals to "Hello World"String helloWorld = (String) parser.parseExpression(
								"'Hello World'").getValue();
								doubleavogadrosNumber = (Double) parser.parseExpression(
								"6.0221415E+23").getValue();
								// evals to 2147483647
								intmaxValue = (Integer) parser.parseExpression(
								"0x7FFFFFFF").getValue();
								booleantrueValue = (Boolean) parser.parseExpression(
								"true").getValue(); Object nullValue = parser.parseExpression(
								"null").getValue();

Numbers support the use of the negative sign, exponential notation, and decimal points. By default real numbers are parsed using Double.parseDouble().

10.5.2 Properties, Arrays, Lists, Maps, Indexers

Navigating with property references is easy: just use a period to indicate a nested property value. The instances of the Inventorclass, pupin, and tesla, were populated with data listed in the section Classes used in the examples. To navigate "down" and get Tesla’s year of birth and Pupin’s city of birth the following expressions are used.

								// evals to 1856
								intyear = (Integer) parser.parseExpression(
								"Birthdate.Year + 1900").getValue(context); String city = (String) parser.parseExpression(
								"placeOfBirth.City").getValue(context);

Case insensitivity is allowed for the first letter of property names. The contents of arrays and lists are obtained using square bracket notation.

ExpressionParser parser =
								newSpelExpressionParser();
								// Inventions ArrayStandardEvaluationContext teslaContext =
								newStandardEvaluationContext(tesla);
								// evaluates to "Induction motor"String invention = parser.parseExpression(
								"inventions[3]").getValue( teslaContext, String.
								class);
								// Members ListStandardEvaluationContext societyContext =
								newStandardEvaluationContext(ieee);
								// evaluates to "Nikola Tesla"String name = parser.parseExpression(
								"Members[0].Name").getValue( societyContext, String.
								class);
								// List and Array navigation
								// evaluates to "Wireless communication"String invention = parser.parseExpression(
								"Members[0].Inventions[6]").getValue( societyContext, String.
								class);

The contents of maps are obtained by specifying the literal key value within the brackets. In this case, because keys for the Officers map are strings, we can specify string literals.

								// Officer's DictionaryInventor pupin = parser.parseExpression(
								"Officers['president']").getValue( societyContext, Inventor.
								class);
								// evaluates to "Idvor"String city = parser.parseExpression(
								"Officers['president'].PlaceOfBirth.City").getValue( societyContext, String.
								class);
								// setting valuesparser.parseExpression(
								"Officers['advisors'][0].PlaceOfBirth.Country").setValue( societyContext,
								"Croatia");

10.5.3 Inline lists

Lists can be expressed directly in an expression using {}notation.

								// evaluates to a Java list containing the four numbersList numbers = (List) parser.parseExpression(
								"{1,2,3,4}").getValue(context); List listOfLists = (List) parser.parseExpression(
								"{{'a','b'},{'x','y'}}").getValue(context);

{}by itself means an empty list. For performance reasons, if the list is itself entirely composed of fixed literals then a constant list is created to represent the expression, rather than building a new list on each evaluation.

10.5.4 Inline Maps

Maps can also be expressed directly in an expression using {key:value}notation.

								// evaluates to a Java map containing the two entriesMap inventorInfo = (Map) parser.parseExpression(
								"{name:'Nikola',dob:'10-July-1856'}").getValue(context); Map mapOfMaps = (Map) parser.parseExpression(
								"{name:{first:'Nikola',last:'Tesla'},dob:{day:10,month:'July',year:1856}}").getValue(context);

{:}by itself means an empty map. For performance reasons, if the map is itself composed of fixed literals or other nested constant structures (lists or maps) then a constant map is created to represent the expression, rather than building a new map on each evaluation. Quoting of the map keys is optional, the examples above are not using quoted keys.

10.5.5 Array construction

Arrays can be built using the familiar Java syntax, optionally supplying an initializer to have the array populated at construction time.

								int[] numbers1 = (
								int[]) parser.parseExpression(
								"new int[4]").getValue(context);
								// Array with initializer
								int[] numbers2 = (
								int[]) parser.parseExpression(
								"new int[]{1,2,3}").getValue(context);
								// Multi dimensional array
								int[][] numbers3 = (
								int[][]) parser.parseExpression(
								"new int[4][5]").getValue(context);

It is not currently allowed to supply an initializer when constructing a multi-dimensional array.

10.5.6 Methods

Methods are invoked using typical Java programming syntax. You may also invoke methods on literals. Varargs are also supported.

								// string literal, evaluates to "bc"String c = parser.parseExpression(
								"'abc'.substring(2, 3)").getValue(String.
								class);
								// evaluates to true
								booleanisMember = parser.parseExpression(
								"isMember('Mihajlo Pupin')").getValue( societyContext, Boolean.
								class);

10.5.7 Operators

Relational operators

The relational operators; equal, not equal, less than, less than or equal, greater than, and greater than or equal are supported using standard operator notation.

									// evaluates to true
									booleantrueValue = parser.parseExpression(
									"2 == 2").getValue(Boolean.
									class);
									// evaluates to false
									booleanfalseValue = parser.parseExpression(
									"2 < -5.0").getValue(Boolean.
									class);
									// evaluates to true
									booleantrueValue = parser.parseExpression(
									"'black' < 'block'").getValue(Boolean.
									class);

In addition to standard relational operators SpEL supports the instanceofand regular expression based matchesoperator.

									// evaluates to false
									booleanfalseValue = parser.parseExpression(
									"'xyz' instanceof T(Integer)").getValue(Boolean.
									class);
									// evaluates to true
									booleantrueValue = parser.parseExpression(
									"'5.00' matches '\^-?\\d+(\\.\\d{2})?$'").getValue(Boolean.
									class);
									//evaluates to false
									booleanfalseValue = parser.parseExpression(
									"'5.0067' matches '\^-?\\d+(\\.\\d{2})?$'").getValue(Boolean.
									class);
[Note] Note

Be careful with primitive types as they are immediately boxed up to the wrapper type, so 1 instanceof T(int)evaluates to falsewhile 1 instanceof T(Integer)evaluates to true, as expected.

Each symbolic operator can also be specified as a purely alphabetic equivalent. This avoids problems where the symbols used have special meaning for the document type in which the expression is embedded (eg. an XML document). The textual equivalents are shown here: lt( <), gt( >), le( ⇐), ge( >=), eq( ==), ne( !=), div( /), mod( %), not( !). These are case insensitive.

Logical operators

The logical operators that are supported are and, or, and not. Their use is demonstrated below.

									// -- AND --
									// evaluates to false
									booleanfalseValue = parser.parseExpression(
									"true and false").getValue(Boolean.
									class);
									// evaluates to trueString expression =
									"isMember('Nikola Tesla') and isMember('Mihajlo Pupin')";
									booleantrueValue = parser.parseExpression(expression).getValue(societyContext, Boolean.
									class);
									// -- OR --
									// evaluates to true
									booleantrueValue = parser.parseExpression(
									"true or false").getValue(Boolean.
									class);
									// evaluates to trueString expression =
									"isMember('Nikola Tesla') or isMember('Albert Einstein')";
									booleantrueValue = parser.parseExpression(expression).getValue(societyContext, Boolean.
									class);
									// -- NOT --
									// evaluates to false
									booleanfalseValue = parser.parseExpression(
									"!true").getValue(Boolean.
									class);
									// -- AND and NOT --String expression =
									"isMember('Nikola Tesla') and !isMember('Mihajlo Pupin')";
									booleanfalseValue = parser.parseExpression(expression).getValue(societyContext, Boolean.
									class);

Mathematical operators

The addition operator can be used on both numbers and strings. Subtraction, multiplication and division can be used only on numbers. Other mathematical operators supported are modulus (%) and exponential power (^). Standard operator precedence is enforced. These operators are demonstrated below.

									// Addition
									inttwo = parser.parseExpression(
									"1 + 1").getValue(Integer.
									class);
									// 2String testString = parser.parseExpression(
									"'test' + ' ' + 'string'").getValue(String.
									class);
									// 'test string'
									// Subtraction
									intfour = parser.parseExpression(
									"1 - -3").getValue(Integer.
									class);
									// 4
									doubled = parser.parseExpression(
									"1000.00 - 1e4").getValue(Double.
									class);
									// -9000
									// Multiplication
									intsix = parser.parseExpression(
									"-2 * -3").getValue(Integer.
									class);
									// 6
									doubletwentyFour = parser.parseExpression(
									"2.0 * 3e0 * 4").getValue(Double.
									class);
									// 24.0
									// Division
									intminusTwo = parser.parseExpression(
									"6 / -3").getValue(Integer.
									class);
									// -2
									doubleone = parser.parseExpression(
									"8.0 / 4e0 / 2").getValue(Double.
									class);
									// 1.0
									// Modulus
									intthree = parser.parseExpression(
									"7 % 4").getValue(Integer.
									class);
									// 3
									intone = parser.parseExpression(
									"8 / 5 % 2").getValue(Integer.
									class);
									// 1
									// Operator precedence
									intminusTwentyOne = parser.parseExpression(
									"1+2-3*8").getValue(Integer.
									class);
									// -21

10.5.8 Assignment

Setting of a property is done by using the assignment operator. This would typically be done within a call to setValuebut can also be done inside a call to getValue.

Inventor inventor =
								newInventor(); StandardEvaluationContext inventorContext =
								newStandardEvaluationContext(inventor); parser.parseExpression(
								"Name").setValue(inventorContext,
								"Alexander Seovic2");
								// alternativelyString aleks = parser.parseExpression(
								"Name = 'Alexandar Seovic'").getValue(inventorContext, String.
								class);

10.5.9 Types

The special Toperator can be used to specify an instance of java.lang.Class (the type). Static methods are invoked using this operator as well. The StandardEvaluationContextuses a TypeLocatorto find types and the StandardTypeLocator(which can be replaced) is built with an understanding of the java.lang package. This means T() references to types within java.lang do not need to be fully qualified, but all other type references must be.

Class dateClass = parser.parseExpression(
								"T(java.util.Date)").getValue(Class.
								class); Class stringClass = parser.parseExpression(
								"T(String)").getValue(Class.
								class);
								booleantrueValue = parser.parseExpression(
								"T(java.math.RoundingMode).CEILING < T(java.math.RoundingMode).FLOOR") .getValue(Boolean.
								class);

10.5.10 Constructors

Constructors can be invoked using the new operator. The fully qualified class name should be used for all but the primitive type and String (where int, float, etc, can be used).

Inventor einstein = p.parseExpression(
								"new org.spring.samples.spel.inventor.Inventor('Albert Einstein', 'German')") .getValue(Inventor.
								class);
								//create new inventor instance within add method of Listp.parseExpression(
								"Members.add(new org.spring.samples.spel.inventor.Inventor(
								'Albert Einstein',
								'German'))
								").getValue(societyContext);

10.5.11 Variables

Variables can be referenced in the expression using the syntax #variableName. Variables are set using the method setVariable on the StandardEvaluationContext.

Inventor tesla =
								newInventor(
								"Nikola Tesla",
								"Serbian"); StandardEvaluationContext context =
								newStandardEvaluationContext(tesla); context.setVariable(
								"newName",
								"Mike Tesla"); parser.parseExpression(
								"Name = #newName").getValue(context); System.out.println(tesla.getName())
								// "Mike Tesla"

The #this and #root variables

The variable #this is always defined and refers to the current evaluation object (against which unqualified references are resolved). The variable #root is always defined and refers to the root context object. Although #this may vary as components of an expression are evaluated, #root always refers to the root.

									// create an array of integersList<Integer> primes =
									newArrayList<Integer>(); primes.addAll(Arrays.asList(
									2,
									3,
									5,
									7,
									11,
									13,
									17));
									// create parser and set variable 'primes' as the array of integersExpressionParser parser =
									newSpelExpressionParser(); StandardEvaluationContext context =
									newStandardEvaluationContext(); context.setVariable(
									"primes",primes);
									// all prime numbers > 10 from the list (using selection ?{...})
									// evaluates to [11, 13, 17]List<Integer> primesGreaterThanTen = (List<Integer>) parser.parseExpression(
									"#primes.?[#this>10]").getValue(context);

10.5.12 Functions

You can extend SpEL by registering user defined functions that can be called within the expression string. The function is registered with the StandardEvaluationContextusing the method.

								public
								voidregisterFunction(String name, Method m)

A reference to a Java Method provides the implementation of the function. For example, a utility method to reverse a string is shown below.

								public
								abstract
								classStringUtils {
								public
								staticString reverseString(String input) { StringBuilder backwards =
								newStringBuilder();
								for(
								inti =
								0; i < input.length(); i++) backwards.append(input.charAt(input.length() -
								1- i)); }
								returnbackwards.toString(); } }

This method is then registered with the evaluation context and can be used within an expression string.

ExpressionParser parser =
								newSpelExpressionParser(); StandardEvaluationContext context =
								newStandardEvaluationContext(); context.registerFunction(
								"reverseString", StringUtils.
								class.getDeclaredMethod(
								"reverseString",
								newClass[] { String.
								class})); String helloWorldReversed = parser.parseExpression(
								"#reverseString('hello')").getValue(context, String.
								class);

10.5.13 Bean references

If the evaluation context has been configured with a bean resolver it is possible to lookup beans from an expression using the (@) symbol.

ExpressionParser parser =
								newSpelExpressionParser(); StandardEvaluationContext context =
								newStandardEvaluationContext(); context.setBeanResolver(
								newMyBeanResolver());
								// This will end up calling resolve(context,"foo") on MyBeanResolver during evaluationObject bean = parser.parseExpression(
								"@foo").getValue(context);

To access a factory bean itself, the bean name should instead be prefixed with a (&) symbol.

ExpressionParser parser =
								newSpelExpressionParser(); StandardEvaluationContext context =
								newStandardEvaluationContext(); context.setBeanResolver(
								newMyBeanResolver());
								// This will end up calling resolve(context,"&foo") on MyBeanResolver during evaluationObject bean = parser.parseExpression(
								"&foo").getValue(context);

10.5.14 Ternary Operator (If-Then-Else)

You can use the ternary operator for performing if-then-else conditional logic inside the expression. A minimal example is:

String falseString = parser.parseExpression(
								"false ? 'trueExp' : 'falseExp'").getValue(String.
								class);

In this case, the boolean false results in returning the string value 'falseExp'. A more realistic example is shown below.

parser.parseExpression(
								"Name").setValue(societyContext,
								"IEEE"); societyContext.setVariable(
								"queryName",
								"Nikola Tesla"); expression =
								"isMember(#queryName)? #queryName + ' is a member of the ' "+
								"+ Name + ' Society' : #queryName + ' is not a member of the ' + Name + ' Society'"; String queryResultString = parser.parseExpression(expression) .getValue(societyContext, String.
								class);
								// queryResultString = "Nikola Tesla is a member of the IEEE Society"

Also see the next section on the Elvis operator for an even shorter syntax for the ternary operator.

10.5.15 The Elvis Operator

The Elvis operator is a shortening of the ternary operator syntax and is used in the Groovylanguage. With the ternary operator syntax you usually have to repeat a variable twice, for example:

String name =
								"Elvis Presley"; String displayName = name != null ? name :
								"Unknown";

Instead you can use the Elvis operator, named for the resemblance to Elvis' hair style.

ExpressionParser parser =
								newSpelExpressionParser(); String name = parser.parseExpression(
								"name?:'Unknown'").getValue(String.
								class); System.out.println(name);
								// 'Unknown'

Here is a more complex example.

ExpressionParser parser =
								newSpelExpressionParser(); Inventor tesla =
								newInventor(
								"Nikola Tesla",
								"Serbian"); StandardEvaluationContext context =
								newStandardEvaluationContext(tesla); String name = parser.parseExpression(
								"Name?:'Elvis Presley'").getValue(context, String.
								class); System.out.println(name);
								// Nikola Teslatesla.setName(null); name = parser.parseExpression(
								"Name?:'Elvis Presley'").getValue(context, String.
								class); System.out.println(name);
								// Elvis Presley

10.5.16 Safe Navigation operator

The Safe Navigation operator is used to avoid a NullPointerExceptionand comes from the Groovylanguage. Typically when you have a reference to an object you might need to verify that it is not null before accessing methods or properties of the object. To avoid this, the safe navigation operator will simply return null instead of throwing an exception.

ExpressionParser parser =
								newSpelExpressionParser(); Inventor tesla =
								newInventor(
								"Nikola Tesla",
								"Serbian"); tesla.setPlaceOfBirth(
								newPlaceOfBirth(
								"Smiljan")); StandardEvaluationContext context =
								newStandardEvaluationContext(tesla); String city = parser.parseExpression(
								"PlaceOfBirth?.City").getValue(context, String.
								class); System.out.println(city);
								// Smiljantesla.setPlaceOfBirth(null); city = parser.parseExpression(
								"PlaceOfBirth?.City").getValue(context, String.
								class); System.out.println(city);
								// null - does not throw NullPointerException!!!
[Note] Note

The Elvis operator can be used to apply default values in expressions, e.g. in an @Valueexpression:

@Value(
												"#{systemProperties['pop3.port'] ?: 25}")

This will inject a system property pop3.portif it is defined or 25 if not.

10.5.17 Collection Selection

Selection is a powerful expression language feature that allows you to transform some source collection into another by selecting from its entries.

Selection uses the syntax ?[selectionExpression]. This will filter the collection and return a new collection containing a subset of the original elements. For example, selection would allow us to easily get a list of Serbian inventors:

List<Inventor> list = (List<Inventor>) parser.parseExpression(
								"Members.?[Nationality == 'Serbian']").getValue(societyContext);

Selection is possible upon both lists and maps. In the former case the selection criteria is evaluated against each individual list element whilst against a map the selection criteria is evaluated against each map entry (objects of the Java type Map.Entry). Map entries have their key and value accessible as properties for use in the selection.

This expression will return a new map consisting of those elements of the original map where the entry value is less than 27.

Map newMap = parser.parseExpression(
								"map.?[value<27]").getValue();

In addition to returning all the selected elements, it is possible to retrieve just the first or the last value. To obtain the first entry matching the selection the syntax is ^[…​]whilst to obtain the last matching selection the syntax is $[…​].

10.5.18 Collection Projection

Projection allows a collection to drive the evaluation of a sub-expression and the result is a new collection. The syntax for projection is ![projectionExpression]. Most easily understood by example, suppose we have a list of inventors but want the list of cities where they were born. Effectively we want to evaluate 'placeOfBirth.city' for every entry in the inventor list. Using projection:

								// returns ['Smiljan', 'Idvor' ]List placesOfBirth = (List)parser.parseExpression(
								"Members.![placeOfBirth.city]");

A map can also be used to drive projection and in this case the projection expression is evaluated against each entry in the map (represented as a Java Map.Entry). The result of a projection across a map is a list consisting of the evaluation of the projection expression against each map entry.

10.5.19 Expression templating

Expression templates allow a mixing of literal text with one or more evaluation blocks. Each evaluation block is delimited with prefix and suffix characters that you can define, a common choice is to use #{ }as the delimiters. For example,

String randomPhrase = parser.parseExpression(
								"random number is #{T(java.lang.Math).random()}",
								newTemplateParserContext()).getValue(String.
								class);
								// evaluates to "random number is 0.7038186818312008"

The string is evaluated by concatenating the literal text 'random number is ' with the result of evaluating the expression inside the #{ } delimiter, in this case the result of calling that random() method. The second argument to the method parseExpression()is of the type ParserContext. The ParserContextinterface is used to influence how the expression is parsed in order to support the expression templating functionality. The definition of TemplateParserContextis shown below.

								public
								classTemplateParserContext
								implementsParserContext {
								publicString getExpressionPrefix() {
								return
								"#{"; }
								publicString getExpressionSuffix() {
								return
								"}"; }
								public
								booleanisTemplate() {
								returntrue; } }

10.6 Classes used in the examples

Inventor.java

							packageorg.spring.samples.spel.inventor;
							importjava.util.Date;
							importjava.util.GregorianCalendar;
							public
							classInventor {
							privateString name;
							privateString nationality;
							privateString[] inventions;
							privateDate birthdate;
							privatePlaceOfBirth placeOfBirth;
							publicInventor(String name, String nationality) { GregorianCalendar c=
							newGregorianCalendar();
							this.name = name;
							this.nationality = nationality;
							this.birthdate = c.getTime(); }
							publicInventor(String name, Date birthdate, String nationality) {
							this.name = name;
							this.nationality = nationality;
							this.birthdate = birthdate; }
							publicInventor() { }
							publicString getName() {
							returnname; }
							public
							voidsetName(String name) {
							this.name = name; }
							publicString getNationality() {
							returnnationality; }
							public
							voidsetNationality(String nationality) {
							this.nationality = nationality; }
							publicDate getBirthdate() {
							returnbirthdate; }
							public
							voidsetBirthdate(Date birthdate) {
							this.birthdate = birthdate; }
							publicPlaceOfBirth getPlaceOfBirth() {
							returnplaceOfBirth; }
							public
							voidsetPlaceOfBirth(PlaceOfBirth placeOfBirth) {
							this.placeOfBirth = placeOfBirth; }
							public
							voidsetInventions(String[] inventions) {
							this.inventions = inventions; }
							publicString[] getInventions() {
							returninventions; } }

PlaceOfBirth.java

							packageorg.spring.samples.spel.inventor;
							public
							classPlaceOfBirth {
							privateString city;
							privateString country;
							publicPlaceOfBirth(String city) {
							this.city=city; }
							publicPlaceOfBirth(String city, String country) {
							this(city);
							this.country = country; }
							publicString getCity() {
							returncity; }
							public
							voidsetCity(String s) {
							this.city = s; }
							publicString getCountry() {
							returncountry; }
							public
							voidsetCountry(String country) {
							this.country = country; } }

Society.java

							packageorg.spring.samples.spel.inventor;
							importjava.util.*;
							public
							classSociety {
							privateString name;
							public
							staticString Advisors =
							"advisors";
							public
							staticString President =
							"president";
							privateList<Inventor> members =
							newArrayList<Inventor>();
							privateMap officers =
							newHashMap();
							publicList getMembers() {
							returnmembers; }
							publicMap getOfficers() {
							returnofficers; }
							publicString getName() {
							returnname; }
							public
							voidsetName(String name) {
							this.name = name; }
							public
							booleanisMember(String name) {
							for(Inventor inventor : members) {
							if(inventor.getName().equals(name)) {
							returntrue; } }
							returnfalse; } }

11. Aspect Oriented Programming with Spring

11.1 Introduction

Aspect-Oriented Programming(AOP) complements Object-Oriented Programming (OOP) by providing another way of thinking about program structure. The key unit of modularity in OOP is the class, whereas in AOP the unit of modularity is the aspect. Aspects enable the modularization of concerns such as transaction management that cut across multiple types and objects. (Such concerns are often termed crosscuttingconcerns in AOP literature.)

One of the key components of Spring is the AOP framework. While the Spring IoC container does not depend on AOP, meaning you do not need to use AOP if you don’t want to, AOP complements Spring IoC to provide a very capable middleware solution.

Spring 2.0 AOP

Spring 2.0 introduces a simpler and more powerful way of writing custom aspects using either a schema-based approachor the @AspectJ annotation style. Both of these styles offer fully typed advice and use of the AspectJ pointcut language, while still using Spring AOP for weaving.

The Spring 2.0 schema- and @AspectJ-based AOP support is discussed in this chapter. Spring 2.0 AOP remains fully backwards compatible with Spring 1.2 AOP, and the lower-level AOP support offered by the Spring 1.2 APIs is discussed in the following chapter.

AOP is used in the Spring Framework to…​

  • …​ provide declarative enterprise services, especially as a replacement for EJB declarative services. The most important such service is declarative transaction management .
  • …​ allow users to implement custom aspects, complementing their use of OOP with AOP.
[Note] Note

If you are interested only in generic declarative services or other pre-packaged declarative middleware services such as pooling, you do not need to work directly with Spring AOP, and can skip most of this chapter.

11.1.1 AOP concepts

Let us begin by defining some central AOP concepts and terminology. These terms are not Spring-specific…​ unfortunately, AOP terminology is not particularly intuitive; however, it would be even more confusing if Spring used its own terminology.

  • Aspect: a modularization of a concern that cuts across multiple classes. Transaction management is a good example of a crosscutting concern in enterprise Java applications. In Spring AOP, aspects are implemented using regular classes (the schema-based approach) or regular classes annotated with the @Aspectannotation (the @AspectJstyle).
  • Join point: a point during the execution of a program, such as the execution of a method or the handling of an exception. In Spring AOP, a join point alwaysrepresents a method execution.
  • Advice: action taken by an aspect at a particular join point. Different types of advice include "around," "before" and "after" advice. (Advice types are discussed below.) Many AOP frameworks, including Spring, model an advice as an interceptor, maintaining a chain of interceptors aroundthe join point.
  • Pointcut: a predicate that matches join points. Advice is associated with a pointcut expression and runs at any join point matched by the pointcut (for example, the execution of a method with a certain name). The concept of join points as matched by pointcut expressions is central to AOP, and Spring uses the AspectJ pointcut expression language by default.
  • Introduction: declaring additional methods or fields on behalf of a type. Spring AOP allows you to introduce new interfaces (and a corresponding implementation) to any advised object. For example, you could use an introduction to make a bean implement an IsModifiedinterface, to simplify caching. (An introduction is known as an inter-type declaration in the AspectJ community.)
  • Target object: object being advised by one or more aspects. Also referred to as the advisedobject. Since Spring AOP is implemented using runtime proxies, this object will always be a proxiedobject.
  • AOP proxy: an object created by the AOP framework in order to implement the aspect contracts (advise method executions and so on). In the Spring Framework, an AOP proxy will be a JDK dynamic proxy or a CGLIB proxy.
  • Weaving: linking aspects with other application types or objects to create an advised object. This can be done at compile time (using the AspectJ compiler, for example), load time, or at runtime. Spring AOP, like other pure Java AOP frameworks, performs weaving at runtime.

Types of advice:

  • Before advice: Advice that executes before a join point, but which does not have the ability to prevent execution flow proceeding to the join point (unless it throws an exception).
  • After returning advice: Advice to be executed after a join point completes normally: for example, if a method returns without throwing an exception.
  • After throwing advice: Advice to be executed if a method exits by throwing an exception.
  • After (finally) advice: Advice to be executed regardless of the means by which a join point exits (normal or exceptional return).
  • Around advice: Advice that surrounds a join point such as a method invocation. This is the most powerful kind of advice. Around advice can perform custom behavior before and after the method invocation. It is also responsible for choosing whether to proceed to the join point or to shortcut the advised method execution by returning its own return value or throwing an exception.

Around advice is the most general kind of advice. Since Spring AOP, like AspectJ, provides a full range of advice types, we recommend that you use the least powerful advice type that can implement the required behavior. For example, if you need only to update a cache with the return value of a method, you are better off implementing an after returning advice than an around advice, although an around advice can accomplish the same thing. Using the most specific advice type provides a simpler programming model with less potential for errors. For example, you do not need to invoke the proceed()method on the JoinPointused for around advice, and hence cannot fail to invoke it.

In Spring 2.0, all advice parameters are statically typed, so that you work with advice parameters of the appropriate type (the type of the return value from a method execution for example) rather than Objectarrays.

The concept of join points, matched by pointcuts, is the key to AOP which distinguishes it from older technologies offering only interception. Pointcuts enable advice to be targeted independently of the Object-Oriented hierarchy. For example, an around advice providing declarative transaction management can be applied to a set of methods spanning multiple objects (such as all business operations in the service layer).

11.1.2 Spring AOP capabilities and goals

Spring AOP is implemented in pure Java. There is no need for a special compilation process. Spring AOP does not need to control the class loader hierarchy, and is thus suitable for use in a Servlet container or application server.

Spring AOP currently supports only method execution join points (advising the execution of methods on Spring beans). Field interception is not implemented, although support for field interception could be added without breaking the core Spring AOP APIs. If you need to advise field access and update join points, consider a language such as AspectJ.

Spring AOP’s approach to AOP differs from that of most other AOP frameworks. The aim is not to provide the most complete AOP implementation (although Spring AOP is quite capable); it is rather to provide a close integration between AOP implementation and Spring IoC to help solve common problems in enterprise applications.

Thus, for example, the Spring Framework’s AOP functionality is normally used in conjunction with the Spring IoC container. Aspects are configured using normal bean definition syntax (although this allows powerful "autoproxying" capabilities): this is a crucial difference from other AOP implementations. There are some things you cannot do easily or efficiently with Spring AOP, such as advise very fine-grained objects (such as domain objects typically): AspectJ is the best choice in such cases. However, our experience is that Spring AOP provides an excellent solution to most problems in enterprise Java applications that are amenable to AOP.

Spring AOP will never strive to compete with AspectJ to provide a comprehensive AOP solution. We believe that both proxy-based frameworks like Spring AOP and full-blown frameworks such as AspectJ are valuable, and that they are complementary, rather than in competition. Spring seamlessly integrates Spring AOP and IoC with AspectJ, to enable all uses of AOP to be catered for within a consistent Spring-based application architecture. This integration does not affect the Spring AOP API or the AOP Alliance API: Spring AOP remains backward-compatible. See the following chapterfor a discussion of the Spring AOP APIs.

[Note] Note

One of the central tenets of the Spring Framework is that of non-invasiveness; this is the idea that you should not be forced to introduce framework-specific classes and interfaces into your business/domain model. However, in some places the Spring Framework does give you the option to introduce Spring Framework-specific dependencies into your codebase: the rationale in giving you such options is because in certain scenarios it might be just plain easier to read or code some specific piece of functionality in such a way. The Spring Framework (almost) always offers you the choice though: you have the freedom to make an informed decision as to which option best suits your particular use case or scenario.

One such choice that is relevant to this chapter is that of which AOP framework (and which AOP style) to choose. You have the choice of AspectJ and/or Spring AOP, and you also have the choice of either the @AspectJ annotation-style approach or the Spring XML configuration-style approach. The fact that this chapter chooses to introduce the @AspectJ-style approach first should not be taken as an indication that the Spring team favors the @AspectJ annotation-style approach over the Spring XML configuration-style.

See Section 11.4, “Choosing which AOP declaration style to use”for a more complete discussion of the whys and wherefores of each style.

11.1.3 AOP Proxies

Spring AOP defaults to using standard JDK dynamic proxiesfor AOP proxies. This enables any interface (or set of interfaces) to be proxied.

Spring AOP can also use CGLIB proxies. This is necessary to proxy classes rather than interfaces. CGLIB is used by default if a business object does not implement an interface. As it is good practice to program to interfaces rather than classes; business classes normally will implement one or more business interfaces. It is possible to force the use of CGLIB, in those (hopefully rare) cases where you need to advise a method that is not declared on an interface, or where you need to pass a proxied object to a method as a concrete type.

It is important to grasp the fact that Spring AOP is proxy-based. See Section 11.6.1, “Understanding AOP proxies”for a thorough examination of exactly what this implementation detail actually means.

11.2 @AspectJ support

@AspectJ refers to a style of declaring aspects as regular Java classes annotated with annotations. The @AspectJ style was introduced by the AspectJ projectas part of the AspectJ 5 release. Spring interprets the same annotations as AspectJ 5, using a library supplied by AspectJ for pointcut parsing and matching. The AOP runtime is still pure Spring AOP though, and there is no dependency on the AspectJ compiler or weaver.

[Note] Note

Using the AspectJ compiler and weaver enables use of the full AspectJ language, and is discussed in Section 11.8, “Using AspectJ with Spring applications”.

11.2.1 Enabling @AspectJ Support

To use @AspectJ aspects in a Spring configuration you need to enable Spring support for configuring Spring AOP based on @AspectJ aspects, and autoproxyingbeans based on whether or not they are advised by those aspects. By autoproxying we mean that if Spring determines that a bean is advised by one or more aspects, it will automatically generate a proxy for that bean to intercept method invocations and ensure that advice is executed as needed.

The @AspectJ support can be enabled with XML or Java style configuration. In either case you will also need to ensure that AspectJ’s aspectjweaver.jarlibrary is on the classpath of your application (version 1.6.8 or later). This library is available in the 'lib'directory of an AspectJ distribution or via the Maven Central repository.

Enabling @AspectJ Support with Java configuration

To enable @AspectJ support with Java @Configurationadd the @EnableAspectJAutoProxyannotation:

									
										@Configuration
									
										@EnableAspectJAutoProxy
									public
									classAppConfig { }

Enabling @AspectJ Support with XML configuration

To enable @AspectJ support with XML based configuration use the aop:aspectj-autoproxyelement:

									<aop:aspectj-autoproxy/>

This assumes that you are using schema support as described in Chapter 41, XML Schema-based configuration . See Section 41.2.7, “the aop schema”for how to import the tags in the aopnamespace.

11.2.2 Declaring an aspect

With the @AspectJ support enabled, any bean defined in your application context with a class that is an @AspectJ aspect (has the @Aspectannotation) will be automatically detected by Spring and used to configure Spring AOP. The following example shows the minimal definition required for a not-very-useful aspect:

A regular bean definition in the application context, pointing to a bean class that has the @Aspectannotation:

								<bean
								id=
								"myAspect"
								class=
								"org.xyz.NotVeryUsefulAspect"
								>
								<!-- configure properties of aspect here as normal -->
								</bean>

And the NotVeryUsefulAspectclass definition, annotated with org.aspectj.lang.annotation.Aspectannotation;

								packageorg.xyz;
								importorg.aspectj.lang.annotation.Aspect;
								
									@Aspect
								public
								classNotVeryUsefulAspect { }

Aspects (classes annotated with @Aspect) may have methods and fields just like any other class. They may also contain pointcut, advice, and introduction (inter-type) declarations.

[Note] Autodetecting aspects through component scanning

You may register aspect classes as regular beans in your Spring XML configuration, or autodetect them through classpath scanning - just like any other Spring-managed bean. However, note that the @Aspectannotation is notsufficient for autodetection in the classpath: For that purpose, you need to add a separate @Componentannotation (or alternatively a custom stereotype annotation that qualifies, as per the rules of Spring’s component scanner).
[Note] Advising aspects with other aspects?

In Spring AOP, it is notpossible to have aspects themselves be the target of advice from other aspects. The @Aspectannotation on a class marks it as an aspect, and hence excludes it from auto-proxying.

11.2.3 Declaring a pointcut

Recall that pointcuts determine join points of interest, and thus enable us to control when advice executes. Spring AOP only supports method execution join points for Spring beans, so you can think of a pointcut as matching the execution of methods on Spring beans. A pointcut declaration has two parts: a signature comprising a name and any parameters, and a pointcut expression that determines exactlywhich method executions we are interested in. In the @AspectJ annotation-style of AOP, a pointcut signature is provided by a regular method definition, and the pointcut expression is indicated using the @Pointcutannotation (the method serving as the pointcut signature musthave a voidreturn type).

An example will help make this distinction between a pointcut signature and a pointcut expression clear. The following example defines a pointcut named 'anyOldTransfer'that will match the execution of any method named 'transfer':

								
									@Pointcut("execution(* transfer(..))")//the pointcut expression
								private
								voidanyOldTransfer() {}
								// the pointcut signature

The pointcut expression that forms the value of the @Pointcutannotation is a regular AspectJ 5 pointcut expression. For a full discussion of AspectJ’s pointcut language, see the AspectJ Programming Guide(and for extensions, the AspectJ 5 Developers Notebook) or one of the books on AspectJ such as "Eclipse AspectJ" by Colyer et. al. or "AspectJ in Action" by Ramnivas Laddad.

Supported Pointcut Designators

Spring AOP supports the following AspectJ pointcut designators (PCD) for use in pointcut expressions:

Other pointcut types

The full AspectJ pointcut language supports additional pointcut designators that are not supported in Spring. These are: call, get, set, preinitialization, staticinitialization, initialization, handler, adviceexecution, withincode, cflow, cflowbelow, if, @this, and @withincode. Use of these pointcut designators in pointcut expressions interpreted by Spring AOP will result in an IllegalArgumentExceptionbeing thrown.

The set of pointcut designators supported by Spring AOP may be extended in future releases to support more of the AspectJ pointcut designators.

  • execution- for matching method execution join points, this is the primary pointcut designator you will use when working with Spring AOP
  • within- limits matching to join points within certain types (simply the execution of a method declared within a matching type when using Spring AOP)
  • this- limits matching to join points (the execution of methods when using Spring AOP) where the bean reference (Spring AOP proxy) is an instance of the given type
  • target- limits matching to join points (the execution of methods when using Spring AOP) where the target object (application object being proxied) is an instance of the given type
  • args- limits matching to join points (the execution of methods when using Spring AOP) where the arguments are instances of the given types
  • @target- limits matching to join points (the execution of methods when using Spring AOP) where the class of the executing object has an annotation of the given type
  • @args- limits matching to join points (the execution of methods when using Spring AOP) where the runtime type of the actual arguments passed have annotations of the given type(s)
  • @within- limits matching to join points within types that have the given annotation (the execution of methods declared in types with the given annotation when using Spring AOP)
  • @annotation- limits matching to join points where the subject of the join point (method being executed in Spring AOP) has the given annotation

Because Spring AOP limits matching to only method execution join points, the discussion of the pointcut designators above gives a narrower definition than you will find in the AspectJ programming guide. In addition, AspectJ itself has type-based semantics and at an execution join point both thisand targetrefer to the same object - the object executing the method. Spring AOP is a proxy-based system and differentiates between the proxy object itself (bound to this) and the target object behind the proxy (bound to target).

[Note] Note

Due to the proxy-based nature of Spring’s AOP framework, protected methods are by definition notintercepted, neither for JDK proxies (where this isn’t applicable) nor for CGLIB proxies (where this is technically possible but not recommendable for AOP purposes). As a consequence, any given pointcut will be matched against public methods only!

If your interception needs include protected/private methods or even constructors, consider the use of Spring-driven native AspectJ weavinginstead of Spring’s proxy-based AOP framework. This constitutes a different mode of AOP usage with different characteristics, so be sure to make yourself familiar with weaving first before making a decision.

Spring AOP also supports an additional PCD named bean. This PCD allows you to limit the matching of join points to a particular named Spring bean, or to a set of named Spring beans (when using wildcards). The beanPCD has the following form:

bean(idOrNameOfBean)

The idOrNameOfBeantoken can be the name of any Spring bean: limited wildcard support using the *character is provided, so if you establish some naming conventions for your Spring beans you can quite easily write a beanPCD expression to pick them out. As is the case with other pointcut designators, the beanPCD can be &&'ed, ||'ed, and ! (negated) too.

[Note] Note

Please note that the beanPCD is onlysupported in Spring AOP - and notin native AspectJ weaving. It is a Spring-specific extension to the standard PCDs that AspectJ defines and therefore not available for aspects declared in the @Aspectmodel.

The beanPCD operates at the instancelevel (building on the Spring bean name concept) rather than at the type level only (which is what weaving-based AOP is limited to). Instance-based pointcut designators are a special capability of Spring’s proxy-based AOP framework and its close integration with the Spring bean factory, where it is natural and straightforward to identify specific beans by name.

Combining pointcut expressions

Pointcut expressions can be combined using '&&', '||' and '!'. It is also possible to refer to pointcut expressions by name. The following example shows three pointcut expressions: anyPublicOperation(which matches if a method execution join point represents the execution of any public method); inTrading(which matches if a method execution is in the trading module), and tradingOperation(which matches if a method execution represents any public method in the trading module).

									
										@Pointcut("execution(public * *(..))")
									private
									voidanyPublicOperation() {}
									
										@Pointcut("within(com.xyz.someapp.trading..*)")
									private
									voidinTrading() {}
									
										@Pointcut("anyPublicOperation() && inTrading()")
									private
									voidtradingOperation() {}

It is a best practice to build more complex pointcut expressions out of smaller named components as shown above. When referring to pointcuts by name, normal Java visibility rules apply (you can see private pointcuts in the same type, protected pointcuts in the hierarchy, public pointcuts anywhere and so on). Visibility does not affect pointcut matching.

Sharing common pointcut definitions

When working with enterprise applications, you often want to refer to modules of the application and particular sets of operations from within several aspects. We recommend defining a "SystemArchitecture" aspect that captures common pointcut expressions for this purpose. A typical such aspect would look as follows:

									packagecom.xyz.someapp;
									importorg.aspectj.lang.annotation.Aspect;
									importorg.aspectj.lang.annotation.Pointcut;
									
										@Aspect
									public
									classSystemArchitecture {
									/** * A join point is in the web layer if the method is defined * in a type in the com.xyz.someapp.web package or any sub-package * under that. */
									
										@Pointcut("within(com.xyz.someapp.web..*)")
									public
									voidinWebLayer() {}
									/** * A join point is in the service layer if the method is defined * in a type in the com.xyz.someapp.service package or any sub-package * under that. */
									
										@Pointcut("within(com.xyz.someapp.service..*)")
									public
									voidinServiceLayer() {}
									/** * A join point is in the data access layer if the method is defined * in a type in the com.xyz.someapp.dao package or any sub-package * under that. */
									
										@Pointcut("within(com.xyz.someapp.dao..*)")
									public
									voidinDataAccessLayer() {}
									/** * A business service is the execution of any method defined on a service * interface. This definition assumes that interfaces are placed in the * "service" package, and that implementation types are in sub-packages. * * If you group service interfaces by functional area (for example, * in packages com.xyz.someapp.abc.service and com.xyz.someapp.def.service) then * the pointcut expression "execution(* com.xyz.someapp..service.*.*(..))" * could be used instead. * * Alternatively, you can write the expression using the 'bean' * PCD, like so "bean(*Service)". (This assumes that you have * named your Spring service beans in a consistent fashion.) */
									
										@Pointcut("execution(* com.xyz.someapp..service.*.*(..))")
									public
									voidbusinessService() {}
									/** * A data access operation is the execution of any method defined on a * dao interface. This definition assumes that interfaces are placed in the * "dao" package, and that implementation types are in sub-packages. */
									
										@Pointcut("execution(* com.xyz.someapp.dao.*.*(..))")
									public
									voiddataAccessOperation() {} }

The pointcuts defined in such an aspect can be referred to anywhere that you need a pointcut expression. For example, to make the service layer transactional, you could write:

									<aop:config>
									<aop:advisor
									pointcut=
									"com.xyz.someapp.SystemArchitecture.businessService()"
									advice-ref=
									"tx-advice"
									/>
									</aop:config>
									<tx:advice
									id=
									"tx-advice"
									>
									<tx:attributes>
									<tx:method
									name=
									"*"
									propagation=
									"REQUIRED"
									/>
									</tx:attributes>
									</tx:advice>

The <aop:config>and <aop:advisor>elements are discussed in Section 11.3, “Schema-based AOP support”. The transaction elements are discussed in Chapter 17, Transaction Management .

Examples

Spring AOP users are likely to use the executionpointcut designator the most often. The format of an execution expression is:

execution(modifiers-pattern? ret-type-pattern declaring-type-pattern?name-pattern(param-pattern)
									throws-pattern?)

All parts except the returning type pattern (ret-type-pattern in the snippet above), name pattern, and parameters pattern are optional. The returning type pattern determines what the return type of the method must be in order for a join point to be matched. Most frequently you will use *as the returning type pattern, which matches any return type. A fully-qualified type name will match only when the method returns the given type. The name pattern matches the method name. You can use the *wildcard as all or part of a name pattern. If specifying a declaring type pattern then include a trailing .to join it to the name pattern component. The parameters pattern is slightly more complex: ()matches a method that takes no parameters, whereas (..)matches any number of parameters (zero or more). The pattern (*)matches a method taking one parameter of any type, (*,String)matches a method taking two parameters, the first can be of any type, the second must be a String. Consult the Language Semanticssection of the AspectJ Programming Guide for more information.

Some examples of common pointcut expressions are given below.

  • the execution of any public method:
execution(
									public* *(..))
  • the execution of any method with a name beginning with "set":
execution(* set*(..))
  • the execution of any method defined by the AccountServiceinterface:
execution(* com.xyz.service.AccountService.*(..))
  • the execution of any method defined in the service package:
execution(* com.xyz.service.*.*(..))
  • the execution of any method defined in the service package or a sub-package:
execution(* com.xyz.service..*.*(..))
  • any join point (method execution only in Spring AOP) within the service package:
within(com.xyz.service.*)
  • any join point (method execution only in Spring AOP) within the service package or a sub-package:
within(com.xyz.service..*)
  • any join point (method execution only in Spring AOP) where the proxy implements the AccountServiceinterface:
									this(com.xyz.service.AccountService)
[Note] Note

'this' is more commonly used in a binding form :- see the following section on advice for how to make the proxy object available in the advice body.
  • any join point (method execution only in Spring AOP) where the target object implements the AccountServiceinterface:
target(com.xyz.service.AccountService)
[Note] Note

'target' is more commonly used in a binding form :- see the following section on advice for how to make the target object available in the advice body.
  • any join point (method execution only in Spring AOP) which takes a single parameter, and where the argument passed at runtime is Serializable:
args(java.io.Serializable)
[Note] Note

'args' is more commonly used in a binding form :- see the following section on advice for how to make the method arguments available in the advice body.

Note that the pointcut given in this example is different to execution(* *(java.io.Serializable)): the args version matches if the argument passed at runtime is Serializable, the execution version matches if the method signature declares a single parameter of type Serializable.

  • any join point (method execution only in Spring AOP) where the target object has an @Transactionalannotation:
@target(org.springframework.transaction.annotation.Transactional)
[Note] Note

'@target' can also be used in a binding form :- see the following section on advice for how to make the annotation object available in the advice body.
  • any join point (method execution only in Spring AOP) where the declared type of the target object has an @Transactionalannotation:
@within(org.springframework.transaction.annotation.Transactional)
[Note] Note

'@within' can also be used in a binding form :- see the following section on advice for how to make the annotation object available in the advice body.
  • any join point (method execution only in Spring AOP) where the executing method has an @Transactionalannotation:
@annotation(org.springframework.transaction.annotation.Transactional)
[Note] Note

'@annotation' can also be used in a binding form :- see the following section on advice for how to make the annotation object available in the advice body.
  • any join point (method execution only in Spring AOP) which takes a single parameter, and where the runtime type of the argument passed has the @Classifiedannotation:
@args(com.xyz.security.Classified)
[Note] Note

'@args' can also be used in a binding form :- see the following section on advice for how to make the annotation object(s) available in the advice body.
  • any join point (method execution only in Spring AOP) on a Spring bean named tradeService:
bean(tradeService)
  • any join point (method execution only in Spring AOP) on Spring beans having names that match the wildcard expression *Service:
bean(*Service)

Writing good pointcuts

During compilation, AspectJ processes pointcuts in order to try and optimize matching performance. Examining code and determining if each join point matches (statically or dynamically) a given pointcut is a costly process. (A dynamic match means the match cannot be fully determined from static analysis and a test will be placed in the code to determine if there is an actual match when the code is running). On first encountering a pointcut declaration, AspectJ will rewrite it into an optimal form for the matching process. What does this mean? Basically pointcuts are rewritten in DNF (Disjunctive Normal Form) and the components of the pointcut are sorted such that those components that are cheaper to evaluate are checked first. This means you do not have to worry about understanding the performance of various pointcut designators and may supply them in any order in a pointcut declaration.

However, AspectJ can only work with what it is told, and for optimal performance of matching you should think about what they are trying to achieve and narrow the search space for matches as much as possible in the definition. The existing designators naturally fall into one of three groups: kinded, scoping and context:

  • Kinded designators are those which select a particular kind of join point. For example: execution, get, set, call, handler
  • Scoping designators are those which select a group of join points of interest (of probably many kinds). For example: within, withincode
  • Contextual designators are those that match (and optionally bind) based on context. For example: this, target, @annotation

A well written pointcut should try and include at least the first two types (kinded and scoping), whilst the contextual designators may be included if wishing to match based on join point context, or bind that context for use in the advice. Supplying either just a kinded designator or just a contextual designator will work but could affect weaving performance (time and memory used) due to all the extra processing and analysis. Scoping designators are very fast to match and their usage means AspectJ can very quickly dismiss groups of join points that should not be further processed - that is why a good pointcut should always include one if possible.

11.2.4 Declaring advice

Advice is associated with a pointcut expression, and runs before, after, or around method executions matched by the pointcut. The pointcut expression may be either a simple reference to a named pointcut, or a pointcut expression declared in place.

Before advice

Before advice is declared in an aspect using the @Beforeannotation:

									importorg.aspectj.lang.annotation.Aspect;
									importorg.aspectj.lang.annotation.Before;
									
										@Aspect
									public
									classBeforeExample {
									
										@Before("com.xyz.myapp.SystemArchitecture.dataAccessOperation()")
									public
									voiddoAccessCheck() {
									// ...} }

If using an in-place pointcut expression we could rewrite the above example as:

									importorg.aspectj.lang.annotation.Aspect;
									importorg.aspectj.lang.annotation.Before;
									
										@Aspect
									public
									classBeforeExample {
									
										@Before("execution(* com.xyz.myapp.dao.*.*(..))")
									public
									voiddoAccessCheck() {
									// ...} }

After returning advice

After returning advice runs when a matched method execution returns normally. It is declared using the @AfterReturningannotation:

									importorg.aspectj.lang.annotation.Aspect;
									importorg.aspectj.lang.annotation.AfterReturning;
									
										@Aspect
									public
									classAfterReturningExample {
									
										@AfterReturning("com.xyz.myapp.SystemArchitecture.dataAccessOperation()")
									public
									voiddoAccessCheck() {
									// ...} }
[Note] Note

Note: it is of course possible to have multiple advice declarations, and other members as well, all inside the same aspect. We’re just showing a single advice declaration in these examples to focus on the issue under discussion at the time.

Sometimes you need access in the advice body to the actual value that was returned. You can use the form of @AfterReturningthat binds the return value for this:

									importorg.aspectj.lang.annotation.Aspect;
									importorg.aspectj.lang.annotation.AfterReturning;
									
										@Aspect
									public
									classAfterReturningExample {
									
										@AfterReturning( pointcut="com.xyz.myapp.SystemArchitecture.dataAccessOperation()", returning="retVal")
									public
									voiddoAccessCheck(Object retVal) {
									// ...} }

The name used in the returningattribute must correspond to the name of a parameter in the advice method. When a method execution returns, the return value will be passed to the advice method as the corresponding argument value. A returningclause also restricts matching to only those method executions that return a value of the specified type ( Objectin this case, which will match any return value).

Please note that it is notpossible to return a totally different reference when using after-returning advice.

After throwing advice

After throwing advice runs when a matched method execution exits by throwing an exception. It is declared using the @AfterThrowingannotation:

									importorg.aspectj.lang.annotation.Aspect;
									importorg.aspectj.lang.annotation.AfterThrowing;
									
										@Aspect
									public
									classAfterThrowingExample {
									
										@AfterThrowing("com.xyz.myapp.SystemArchitecture.dataAccessOperation()")
									public
									voiddoRecoveryActions() {
									// ...} }

Often you want the advice to run only when exceptions of a given type are thrown, and you also often need access to the thrown exception in the advice body. Use the throwingattribute to both restrict matching (if desired, use Throwableas the exception type otherwise) and bind the thrown exception to an advice parameter.

									importorg.aspectj.lang.annotation.Aspect;
									importorg.aspectj.lang.annotation.AfterThrowing;
									
										@Aspect
									public
									classAfterThrowingExample {
									
										@AfterThrowing( pointcut="com.xyz.myapp.SystemArchitecture.dataAccessOperation()", throwing="ex")
									public
									voiddoRecoveryActions(DataAccessException ex) {
									// ...} }

The name used in the throwingattribute must correspond to the name of a parameter in the advice method. When a method execution exits by throwing an exception, the exception will be passed to the advice method as the corresponding argument value. A throwingclause also restricts matching to only those method executions that throw an exception of the specified type ( DataAccessExceptionin this case).

After (finally) advice

After (finally) advice runs however a matched method execution exits. It is declared using the @Afterannotation. After advice must be prepared to handle both normal and exception return conditions. It is typically used for releasing resources, etc.

									importorg.aspectj.lang.annotation.Aspect;
									importorg.aspectj.lang.annotation.After;
									
										@Aspect
									public
									classAfterFinallyExample {
									
										@After("com.xyz.myapp.SystemArchitecture.dataAccessOperation()")
									public
									voiddoReleaseLock() {
									// ...} }

Around advice

The final kind of advice is around advice. Around advice runs "around" a matched method execution. It has the opportunity to do work both before and after the method executes, and to determine when, how, and even if, the method actually gets to execute at all. Around advice is often used if you need to share state before and after a method execution in a thread-safe manner (starting and stopping a timer for example). Always use the least powerful form of advice that meets your requirements (i.e. don’t use around advice if simple before advice would do).

Around advice is declared using the @Aroundannotation. The first parameter of the advice method must be of type ProceedingJoinPoint. Within the body of the advice, calling proceed()on the ProceedingJoinPointcauses the underlying method to execute. The proceedmethod may also be called passing in an Object[]- the values in the array will be used as the arguments to the method execution when it proceeds.

[Note] Note

The behavior of proceed when called with an Object[] is a little different than the behavior of proceed for around advice compiled by the AspectJ compiler. For around advice written using the traditional AspectJ language, the number of arguments passed to proceed must match the number of arguments passed to the around advice (not the number of arguments taken by the underlying join point), and the value passed to proceed in a given argument position supplants the original value at the join point for the entity the value was bound to (Don’t worry if this doesn’t make sense right now!). The approach taken by Spring is simpler and a better match to its proxy-based, execution only semantics. You only need to be aware of this difference if you are compiling @AspectJ aspects written for Spring and using proceed with arguments with the AspectJ compiler and weaver. There is a way to write such aspects that is 100% compatible across both Spring AOP and AspectJ, and this is discussed in the following section on advice parameters.

 
									importorg.aspectj.lang.annotation.Aspect;
									importorg.aspectj.lang.annotation.Around;
									importorg.aspectj.lang.ProceedingJoinPoint;
									
										@Aspect
									public
									classAroundExample {
									
										@Around("com.xyz.myapp.SystemArchitecture.businessService()")
									publicObject doBasicProfiling(ProceedingJoinPoint pjp)
									throwsThrowable {
									// start stopwatchObject retVal = pjp.proceed();
									// stop stopwatch
									returnretVal; } }

The value returned by the around advice will be the return value seen by the caller of the method. A simple caching aspect for example could return a value from a cache if it has one, and invoke proceed() if it does not. Note that proceed may be invoked once, many times, or not at all within the body of the around advice, all of these are quite legal.

Advice parameters

Spring offers fully typed advice - meaning that you declare the parameters you need in the advice signature (as we saw for the returning and throwing examples above) rather than work with Object[]arrays all the time. We’ll see how to make argument and other contextual values available to the advice body in a moment. First let’s take a look at how to write generic advice that can find out about the method the advice is currently advising.

Access to the current JoinPoint

Any advice method may declare as its first parameter, a parameter of type org.aspectj.lang.JoinPoint(please note that around advice is requiredto declare a first parameter of type ProceedingJoinPoint, which is a subclass of JoinPoint. The JoinPointinterface provides a number of useful methods such as getArgs()(returns the method arguments), getThis()(returns the proxy object), getTarget()(returns the target object), getSignature()(returns a description of the method that is being advised) and toString()(prints a useful description of the method being advised). Please do consult the javadocs for full details.

Passing parameters to advice

We’ve already seen how to bind the returned value or exception value (using after returning and after throwing advice). To make argument values available to the advice body, you can use the binding form of args. If a parameter name is used in place of a type name in an args expression, then the value of the corresponding argument will be passed as the parameter value when the advice is invoked. An example should make this clearer. Suppose you want to advise the execution of dao operations that take an Account object as the first parameter, and you need access to the account in the advice body. You could write the following:

										
											@Before("com.xyz.myapp.SystemArchitecture.dataAccessOperation() && args(account,..)")
										public
										voidvalidateAccount(Account account) {
										// ...}

The args(account,..)part of the pointcut expression serves two purposes: firstly, it restricts matching to only those method executions where the method takes at least one parameter, and the argument passed to that parameter is an instance of Account; secondly, it makes the actual Accountobject available to the advice via the accountparameter.

Another way of writing this is to declare a pointcut that "provides" the Accountobject value when it matches a join point, and then just refer to the named pointcut from the advice. This would look as follows:

										
											@Pointcut("com.xyz.myapp.SystemArchitecture.dataAccessOperation() && args(account,..)")
										private
										voidaccountDataAccessOperation(Account account) {}
										
											@Before("accountDataAccessOperation(account)")
										public
										voidvalidateAccount(Account account) {
										// ...}

The interested reader is once more referred to the AspectJ programming guide for more details.

The proxy object ( this), target object ( target), and annotations ( @within, @target, @annotation, @args) can all be bound in a similar fashion. The following example shows how you could match the execution of methods annotated with an @Auditableannotation, and extract the audit code.

First the definition of the @Auditableannotation:

										
											@Retention(RetentionPolicy.RUNTIME)
										
											@Target(ElementType.METHOD)
										public
										
											@interfaceAuditable { AuditCode value(); }

And then the advice that matches the execution of @Auditablemethods:

										
											@Before("com.xyz.lib.Pointcuts.anyPublicMethod() && @annotation(auditable)")
										public
										voidaudit(Auditable auditable) { AuditCode code = auditable.value();
										// ...}
Advice parameters and generics

Spring AOP can handle generics used in class declarations and method parameters. Suppose you have a generic type like this:

										public
										interfaceSample<T> {
										voidsampleGenericMethod(T param);
										voidsampleGenericCollectionMethod(Collection<T> param); }

You can restrict interception of method types to certain parameter types by simply typing the advice parameter to the parameter type you want to intercept the method for:

										
											@Before("execution(* ..Sample+.sampleGenericMethod(*)) && args(param)")
										public
										voidbeforeSampleMethod(MyType param) {
										// Advice implementation}

That this works is pretty obvious as we already discussed above. However, it’s worth pointing out that this won’t work for generic collections. So you cannot define a pointcut like this:

										
											@Before("execution(* ..Sample+.sampleGenericCollectionMethod(*)) && args(param)")
										public
										voidbeforeSampleMethod(Collection<MyType> param) {
										// Advice implementation}

To make this work we would have to inspect every element of the collection, which is not reasonable as we also cannot decide how to treat nullvalues in general. To achieve something similar to this you have to type the parameter to Collection<?>and manually check the type of the elements.

Determining argument names

The parameter binding in advice invocations relies on matching names used in pointcut expressions to declared parameter names in (advice and pointcut) method signatures. Parameter names are notavailable through Java reflection, so Spring AOP uses the following strategies to determine parameter names:

  • If the parameter names have been specified by the user explicitly, then the specified parameter names are used: both the advice and the pointcut annotations have an optional "argNames" attribute which can be used to specify the argument names of the annotated method - these argument names areavailable at runtime. For example:
										
											@Before(value="com.xyz.lib.Pointcuts.anyPublicMethod() && target(bean) && @annotation(auditable)", argNames="bean,auditable")
										public
										voidaudit(Object bean, Auditable auditable) { AuditCode code = auditable.value();
										// ... use code and bean}

If the first parameter is of the JoinPoint, ProceedingJoinPoint, or JoinPoint.StaticParttype, you may leave out the name of the parameter from the value of the "argNames" attribute. For example, if you modify the preceding advice to receive the join point object, the "argNames" attribute need not include it:

										
											@Before(value="com.xyz.lib.Pointcuts.anyPublicMethod() && target(bean) && @annotation(auditable)", argNames="bean,auditable")
										public
										voidaudit(JoinPoint jp, Object bean, Auditable auditable) { AuditCode code = auditable.value();
										// ... use code, bean, and jp}

The special treatment given to the first parameter of the JoinPoint, ProceedingJoinPoint, and JoinPoint.StaticParttypes is particularly convenient for advice that do not collect any other join point context. In such situations, you may simply omit the "argNames" attribute. For example, the following advice need not declare the "argNames" attribute:

										
											@Before("com.xyz.lib.Pointcuts.anyPublicMethod()")
										public
										voidaudit(JoinPoint jp) {
										// ... use jp}
  • Using the 'argNames'attribute is a little clumsy, so if the 'argNames'attribute has not been specified, then Spring AOP will look at the debug information for the class and try to determine the parameter names from the local variable table. This information will be present as long as the classes have been compiled with debug information ( '-g:vars'at a minimum). The consequences of compiling with this flag on are: (1) your code will be slightly easier to understand (reverse engineer), (2) the class file sizes will be very slightly bigger (typically inconsequential), (3) the optimization to remove unused local variables will not be applied by your compiler. In other words, you should encounter no difficulties building with this flag on.
[Note] Note

If an @AspectJ aspect has been compiled by the AspectJ compiler (ajc) even without the debug information then there is no need to add the argNames attribute as the compiler will retain the needed information.
  • If the code has been compiled without the necessary debug information, then Spring AOP will attempt to deduce the pairing of binding variables to parameters (for example, if only one variable is bound in the pointcut expression, and the advice method only takes one parameter, the pairing is obvious!). If the binding of variables is ambiguous given the available information, then an AmbiguousBindingExceptionwill be thrown.
  • If all of the above strategies fail then an IllegalArgumentExceptionwill be thrown.
Proceeding with arguments

We remarked earlier that we would describe how to write a proceed call with argumentsthat works consistently across Spring AOP and AspectJ. The solution is simply to ensure that the advice signature binds each of the method parameters in order. For example:

										
											@Around("execution(List<Account> find*(..)) && " + "com.xyz.myapp.SystemArchitecture.inDataAccessLayer() && " + "args(accountHolderNamePattern)")
										publicObject preProcessQueryPattern(ProceedingJoinPoint pjp, String accountHolderNamePattern)
										throwsThrowable { String newPattern = preProcess(accountHolderNamePattern);
										returnpjp.proceed(
										newObject[] {newPattern}); }

In many cases you will be doing this binding anyway (as in the example above).

Advice ordering

What happens when multiple pieces of advice all want to run at the same join point? Spring AOP follows the same precedence rules as AspectJ to determine the order of advice execution. The highest precedence advice runs first "on the way in" (so given two pieces of before advice, the one with highest precedence runs first). "On the way out" from a join point, the highest precedence advice runs last (so given two pieces of after advice, the one with the highest precedence will run second).

When two pieces of advice defined in differentaspects both need to run at the same join point, unless you specify otherwise the order of execution is undefined. You can control the order of execution by specifying precedence. This is done in the normal Spring way by either implementing the org.springframework.core.Orderedinterface in the aspect class or annotating it with the Orderannotation. Given two aspects, the aspect returning the lower value from Ordered.getValue()(or the annotation value) has the higher precedence.

When two pieces of advice defined in the sameaspect both need to run at the same join point, the ordering is undefined (since there is no way to retrieve the declaration order via reflection for javac-compiled classes). Consider collapsing such advice methods into one advice method per join point in each aspect class, or refactor the pieces of advice into separate aspect classes - which can be ordered at the aspect level.

11.2.5 Introductions

Introductions (known as inter-type declarations in AspectJ) enable an aspect to declare that advised objects implement a given interface, and to provide an implementation of that interface on behalf of those objects.

An introduction is made using the @DeclareParentsannotation. This annotation is used to declare that matching types have a new parent (hence the name). For example, given an interface UsageTracked, and an implementation of that interface DefaultUsageTracked, the following aspect declares that all implementors of service interfaces also implement the UsageTrackedinterface. (In order to expose statistics via JMX for example.)

								
									@Aspect
								public
								classUsageTracking {
								
									@DeclareParents(value="com.xzy.myapp.service.*+", defaultImpl=DefaultUsageTracked.class)
								public
								staticUsageTracked mixin;
								
									@Before("com.xyz.myapp.SystemArchitecture.businessService() && this(usageTracked)")
								public
								voidrecordUsage(UsageTracked usageTracked) { usageTracked.incrementUseCount(); } }

The interface to be implemented is determined by the type of the annotated field. The valueattribute of the @DeclareParentsannotation is an AspectJ type pattern :- any bean of a matching type will implement the UsageTracked interface. Note that in the before advice of the above example, service beans can be directly used as implementations of the UsageTrackedinterface. If accessing a bean programmatically you would write the following:

UsageTracked usageTracked = (UsageTracked) context.getBean(
								"myService");

11.2.6 Aspect instantiation models

[Note] Note

(This is an advanced topic, so if you are just starting out with AOP you can safely skip it until later.)

By default there will be a single instance of each aspect within the application context. AspectJ calls this the singleton instantiation model. It is possible to define aspects with alternate lifecycles :- Spring supports AspectJ’s perthisand pertargetinstantiation models ( percflow, percflowbelow,and pertypewithinare not currently supported).

A "perthis" aspect is declared by specifying a perthisclause in the @Aspectannotation. Let’s look at an example, and then we’ll explain how it works.

								
									@Aspect("perthis(com.xyz.myapp.SystemArchitecture.businessService())")
								public
								classMyAspect {
								private
								intsomeState;
								
									@Before(com.xyz.myapp.SystemArchitecture.businessService())
								public
								voidrecordServiceUsage() {
								// ...} }

The effect of the 'perthis'clause is that one aspect instance will be created for each unique service object executing a business service (each unique object bound to 'this' at join points matched by the pointcut expression). The aspect instance is created the first time that a method is invoked on the service object. The aspect goes out of scope when the service object goes out of scope. Before the aspect instance is created, none of the advice within it executes. As soon as the aspect instance has been created, the advice declared within it will execute at matched join points, but only when the service object is the one this aspect is associated with. See the AspectJ programming guide for more information on per-clauses.

The 'pertarget'instantiation model works in exactly the same way as perthis, but creates one aspect instance for each unique target object at matched join points.

11.2.7 Example

Now that you have seen how all the constituent parts work, let’s put them together to do something useful!

The execution of business services can sometimes fail due to concurrency issues (for example, deadlock loser). If the operation is retried, it is quite likely to succeed next time round. For business services where it is appropriate to retry in such conditions (idempotent operations that don’t need to go back to the user for conflict resolution), we’d like to transparently retry the operation to avoid the client seeing a PessimisticLockingFailureException. This is a requirement that clearly cuts across multiple services in the service layer, and hence is ideal for implementing via an aspect.

Because we want to retry the operation, we will need to use around advice so that we can call proceed multiple times. Here’s how the basic aspect implementation looks:

								
									@Aspect
								public
								classConcurrentOperationExecutor
								implementsOrdered {
								private
								static
								final
								intDEFAULT_MAX_RETRIES =
								2;
								private
								intmaxRetries = DEFAULT_MAX_RETRIES;
								private
								intorder =
								1;
								public
								voidsetMaxRetries(
								intmaxRetries) {
								this.maxRetries = maxRetries; }
								public
								intgetOrder() {
								return
								this.order; }
								public
								voidsetOrder(
								intorder) {
								this.order = order; }
								
									@Around("com.xyz.myapp.SystemArchitecture.businessService()")
								publicObject doConcurrentOperation(ProceedingJoinPoint pjp)
								throwsThrowable {
								intnumAttempts =
								0; PessimisticLockingFailureException lockFailureException;
								do{ numAttempts++;
								try{
								returnpjp.proceed(); }
								catch(PessimisticLockingFailureException ex) { lockFailureException = ex; } }
								while(numAttempts <=
								this.maxRetries);
								throwlockFailureException; } }

Note that the aspect implements the Orderedinterface so we can set the precedence of the aspect higher than the transaction advice (we want a fresh transaction each time we retry). The maxRetriesand orderproperties will both be configured by Spring. The main action happens in the doConcurrentOperationaround advice. Notice that for the moment we’re applying the retry logic to all businessService()s. We try to proceed, and if we fail with an PessimisticLockingFailureExceptionwe simply try again unless we have exhausted all of our retry attempts.

The corresponding Spring configuration is:

								<aop:aspectj-autoproxy/>
								<bean
								id=
								"concurrentOperationExecutor"
								class=
								"com.xyz.myapp.service.impl.ConcurrentOperationExecutor"
								>
								<property
								name=
								"maxRetries"
								value=
								"3"
								/>
								<property
								name=
								"order"
								value=
								"100"
								/>
								</bean>

To refine the aspect so that it only retries idempotent operations, we might define an Idempotentannotation:

								
									@Retention(RetentionPolicy.RUNTIME)
								public
								
									@interfaceIdempotent {
								// marker annotation}

and use the annotation to annotate the implementation of service operations. The change to the aspect to only retry idempotent operations simply involves refining the pointcut expression so that only @Idempotentoperations match:

								
									@Around("com.xyz.myapp.SystemArchitecture.businessService() && " + "@annotation(com.xyz.myapp.service.Idempotent)")
								publicObject doConcurrentOperation(ProceedingJoinPoint pjp)
								throwsThrowable { ... }

11.3 Schema-based AOP support

If you prefer an XML-based format, then Spring also offers support for defining aspects using the new "aop" namespace tags. The exact same pointcut expressions and advice kinds are supported as when using the @AspectJ style, hence in this section we will focus on the new syntaxand refer the reader to the discussion in the previous section ( Section 11.2, “@AspectJ support”) for an understanding of writing pointcut expressions and the binding of advice parameters.

To use the aop namespace tags described in this section, you need to import the spring-aopschema as described in Chapter 41, XML Schema-based configuration . See Section 41.2.7, “the aop schema”for how to import the tags in the aopnamespace.

Within your Spring configurations, all aspect and advisor elements must be placed within an <aop:config>element (you can have more than one <aop:config>element in an application context configuration). An <aop:config>element can contain pointcut, advisor, and aspect elements (note these must be declared in that order).

[Warning] Warning

The <aop:config>style of configuration makes heavy use of Spring’s auto-proxyingmechanism. This can cause issues (such as advice not being woven) if you are already using explicit auto-proxying via the use of BeanNameAutoProxyCreatoror suchlike. The recommended usage pattern is to use either just the <aop:config>style, or just the AutoProxyCreatorstyle.

11.3.1 Declaring an aspect

Using the schema support, an aspect is simply a regular Java object defined as a bean in your Spring application context. The state and behavior is captured in the fields and methods of the object, and the pointcut and advice information is captured in the XML.

An aspect is declared using the <aop:aspect> element, and the backing bean is referenced using the refattribute:

								<aop:config>
								<aop:aspect
								id=
								"myAspect"
								ref=
								"aBean"
								>...
								</aop:aspect>
								</aop:config>
								<bean
								id=
								"aBean"
								class=
								"..."
								>...
								</bean>

The bean backing the aspect (" `aBean`" in this case) can of course be configured and dependency injected just like any other Spring bean.

11.3.2 Declaring a pointcut

A named pointcut can be declared inside an <aop:config> element, enabling the pointcut definition to be shared across several aspects and advisors.

A pointcut representing the execution of any business service in the service layer could be defined as follows:

								<aop:config>
								<aop:pointcut
								id=
								"businessService"
								expression=
								"execution(* com.xyz.myapp.service.*.*(..))"
								/>
								</aop:config>

Note that the pointcut expression itself is using the same AspectJ pointcut expression language as described in Section 11.2, “@AspectJ support”. If you are using the schema based declaration style, you can refer to named pointcuts defined in types (@Aspects) within the pointcut expression. Another way of defining the above pointcut would be:

								<aop:config>
								<aop:pointcut
								id=
								"businessService"
								expression=
								"com.xyz.myapp.SystemArchitecture.businessService()"
								/>
								</aop:config>

Assuming you have a SystemArchitectureaspect as described in the section called “Sharing common pointcut definitions”.

Declaring a pointcut inside an aspect is very similar to declaring a top-level pointcut:

								<aop:config>
								<aop:aspect
								id=
								"myAspect"
								ref=
								"aBean"
								>
								<aop:pointcut
								id=
								"businessService"
								expression=
								"execution(* com.xyz.myapp.service.*.*(..))"
								/>...
								</aop:aspect>
								</aop:config>

Much the same way in an @AspectJ aspect, pointcuts declared using the schema based definition style may collect join point context. For example, the following pointcut collects the 'this' object as the join point context and passes it to advice:

								<aop:config>
								<aop:aspect
								id=
								"myAspect"
								ref=
								"aBean"
								>
								<aop:pointcut
								id=
								"businessService"
								expression=
								"execution(* com.xyz.myapp.service.*.*(..)) &amp;&amp; this(service)"
								/>
								<aop:before
								pointcut-ref=
								"businessService"
								method=
								"monitor"
								/>...
								</aop:aspect>
								</aop:config>

The advice must be declared to receive the collected join point context by including parameters of the matching names:

								public
								voidmonitor(Object service) { ... }

When combining pointcut sub-expressions, '&&' is awkward within an XML document, and so the keywords 'and', 'or' and 'not' can be used in place of '&&', '||' and '!' respectively. For example, the previous pointcut may be better written as:

								<aop:config>
								<aop:aspect
								id=
								"myAspect"
								ref=
								"aBean"
								>
								<aop:pointcut
								id=
								"businessService"
								expression=
								"execution(* com.xyz.myapp.service.*.*(..)) **and** this(service)"
								/>
								<aop:before
								pointcut-ref=
								"businessService"
								method=
								"monitor"
								/>...
								</aop:aspect>
								</aop:config>

Note that pointcuts defined in this way are referred to by their XML id and cannot be used as named pointcuts to form composite pointcuts. The named pointcut support in the schema based definition style is thus more limited than that offered by the @AspectJ style.

11.3.3 Declaring advice

The same five advice kinds are supported as for the @AspectJ style, and they have exactly the same semantics.

Before advice

Before advice runs before a matched method execution. It is declared inside an <aop:aspect>using the <aop:before> element.

									<aop:aspect
									id=
									"beforeExample"
									ref=
									"aBean"
									>
									<aop:before
									pointcut-ref=
									"dataAccessOperation"
									method=
									"doAccessCheck"
									/>...
									</aop:aspect>

Here dataAccessOperationis the id of a pointcut defined at the top ( <aop:config>) level. To define the pointcut inline instead, replace the pointcut-refattribute with a pointcutattribute:

									<aop:aspect
									id=
									"beforeExample"
									ref=
									"aBean"
									>
									<aop:before
									pointcut=
									"execution(* com.xyz.myapp.dao.*.*(..))"
									method=
									"doAccessCheck"
									/>...
									</aop:aspect>

As we noted in the discussion of the @AspectJ style, using named pointcuts can significantly improve the readability of your code.

The method attribute identifies a method ( doAccessCheck) that provides the body of the advice. This method must be defined for the bean referenced by the aspect element containing the advice. Before a data access operation is executed (a method execution join point matched by the pointcut expression), the "doAccessCheck" method on the aspect bean will be invoked.

After returning advice

After returning advice runs when a matched method execution completes normally. It is declared inside an <aop:aspect>in the same way as before advice. For example:

									<aop:aspect
									id=
									"afterReturningExample"
									ref=
									"aBean"
									>
									<aop:after-returning
									pointcut-ref=
									"dataAccessOperation"
									method=
									"doAccessCheck"
									/>...
									</aop:aspect>

Just as in the @AspectJ style, it is possible to get hold of the return value within the advice body. Use the returning attribute to specify the name of the parameter to which the return value should be passed:

									<aop:aspect
									id=
									"afterReturningExample"
									ref=
									"aBean"
									>
									<aop:after-returning
									pointcut-ref=
									"dataAccessOperation"
									returning=
									"retVal"
									method=
									"doAccessCheck"
									/>...
									</aop:aspect>

The doAccessCheck method must declare a parameter named retVal. The type of this parameter constrains matching in the same way as described for @AfterReturning. For example, the method signature may be declared as:

									public
									voiddoAccessCheck(Object retVal) {...

After throwing advice

After throwing advice executes when a matched method execution exits by throwing an exception. It is declared inside an <aop:aspect>using the after-throwing element:

									<aop:aspect
									id=
									"afterThrowingExample"
									ref=
									"aBean"
									>
									<aop:after-throwing
									pointcut-ref=
									"dataAccessOperation"
									method=
									"doRecoveryActions"
									/>...
									</aop:aspect>

Just as in the @AspectJ style, it is possible to get hold of the thrown exception within the advice body. Use the throwing attribute to specify the name of the parameter to which the exception should be passed:

									<aop:aspect
									id=
									"afterThrowingExample"
									ref=
									"aBean"
									>
									<aop:after-throwing
									pointcut-ref=
									"dataAccessOperation"
									throwing=
									"dataAccessEx"
									method=
									"doRecoveryActions"
									/>...
									</aop:aspect>

The doRecoveryActions method must declare a parameter named dataAccessEx. The type of this parameter constrains matching in the same way as described for @AfterThrowing. For example, the method signature may be declared as:

									public
									voiddoRecoveryActions(DataAccessException dataAccessEx) {...

After (finally) advice

After (finally) advice runs however a matched method execution exits. It is declared using the afterelement:

									<aop:aspect
									id=
									"afterFinallyExample"
									ref=
									"aBean"
									>
									<aop:after
									pointcut-ref=
									"dataAccessOperation"
									method=
									"doReleaseLock"
									/>...
									</aop:aspect>

Around advice

The final kind of advice is around advice. Around advice runs "around" a matched method execution. It has the opportunity to do work both before and after the method executes, and to determine when, how, and even if, the method actually gets to execute at all. Around advice is often used if you need to share state before and after a method execution in a thread-safe manner (starting and stopping a timer for example). Always use the least powerful form of advice that meets your requirements; don’t use around advice if simple before advice would do.

Around advice is declared using the aop:aroundelement. The first parameter of the advice method must be of type ProceedingJoinPoint. Within the body of the advice, calling proceed()on the ProceedingJoinPointcauses the underlying method to execute. The proceedmethod may also be calling passing in an Object[]- the values in the array will be used as the arguments to the method execution when it proceeds. See the section called “Around advice”for notes on calling proceed with an Object[].

									<aop:aspect
									id=
									"aroundExample"
									ref=
									"aBean"
									>
									<aop:around
									pointcut-ref=
									"businessService"
									method=
									"doBasicProfiling"
									/>...
									</aop:aspect>

The implementation of the doBasicProfilingadvice would be exactly the same as in the @AspectJ example (minus the annotation of course):

									publicObject doBasicProfiling(ProceedingJoinPoint pjp)
									throwsThrowable {
									// start stopwatchObject retVal = pjp.proceed();
									// stop stopwatch
									returnretVal; }

Advice parameters

The schema based declaration style supports fully typed advice in the same way as described for the @AspectJ support - by matching pointcut parameters by name against advice method parameters. See the section called “Advice parameters”for details. If you wish to explicitly specify argument names for the advice methods (not relying on the detection strategies previously described) then this is done using the arg-namesattribute of the advice element, which is treated in the same manner to the "argNames" attribute in an advice annotation as described in the section called “Determining argument names”. For example:

									<aop:before
									pointcut=
									"com.xyz.lib.Pointcuts.anyPublicMethod() and @annotation(auditable)"
									method=
									"audit"
									arg-names=
									"auditable"
									/>

The arg-namesattribute accepts a comma-delimited list of parameter names.

Find below a slightly more involved example of the XSD-based approach that illustrates some around advice used in conjunction with a number of strongly typed parameters.

									packagex.y.service;
									public
									interfaceFooService { Foo getFoo(String fooName,
									intage); }
									public
									classDefaultFooService
									implementsFooService {
									publicFoo getFoo(String name,
									intage) {
									return
									newFoo(name, age); } }

Next up is the aspect. Notice the fact that the profile(..)method accepts a number of strongly-typed parameters, the first of which happens to be the join point used to proceed with the method call: the presence of this parameter is an indication that the profile(..)is to be used as aroundadvice:

									packagex.y;
									importorg.aspectj.lang.ProceedingJoinPoint;
									importorg.springframework.util.StopWatch;
									public
									classSimpleProfiler {
									publicObject profile(ProceedingJoinPoint call, String name,
									intage)
									throwsThrowable { StopWatch clock =
									newStopWatch(
									"Profiling for '"+ name +
									"' and '"+ age +
									"'");
									try{ clock.start(call.toShortString());
									returncall.proceed(); }
									finally{ clock.stop(); System.out.println(clock.prettyPrint()); } } }

Finally, here is the XML configuration that is required to effect the execution of the above advice for a particular join point:

									<beans
									xmlns=
									"http://www.springframework.org/schema/beans"
									xmlns:xsi=
									"http://www.w3.org/2001/XMLSchema-instance"
									xmlns:aop=
									"http://www.springframework.org/schema/aop"
									xsi:schemaLocation=
									" http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd"
									>
									<!-- this is the object that will be proxied by Spring's AOP infrastructure -->
									<bean
									id=
									"fooService"
									class=
									"x.y.service.DefaultFooService"
									/>
									<!-- this is the actual advice itself -->
									<bean
									id=
									"profiler"
									class=
									"x.y.SimpleProfiler"
									/>
									<aop:config>
									<aop:aspect
									ref=
									"profiler"
									>
									<aop:pointcut
									id=
									"theExecutionOfSomeFooServiceMethod"
									expression=
									"execution(* x.y.service.FooService.getFoo(String,int)) and args(name, age)"
									/>
									<aop:around
									pointcut-ref=
									"theExecutionOfSomeFooServiceMethod"
									method=
									"profile"
									/>
									</aop:aspect>
									</aop:config>
									</beans>

If we had the following driver script, we would get output something like this on standard output:

									importorg.springframework.beans.factory.BeanFactory;
									importorg.springframework.context.support.ClassPathXmlApplicationContext;
									importx.y.service.FooService;
									public
									final
									classBoot {
									public
									static
									voidmain(
									finalString[] args)
									throwsException { BeanFactory ctx =
									newClassPathXmlApplicationContext(
									"x/y/plain.xml"); FooService foo = (FooService) ctx.getBean(
									"fooService"); foo.getFoo(
									"Pengo",
									12); } }
StopWatch 'Profiling for 'Pengo' and '12'': running time (millis) = 0 ----------------------------------------- ms % Task name ----------------------------------------- 00000 ? execution(getFoo)

Advice ordering

When multiple advice needs to execute at the same join point (executing method) the ordering rules are as described in the section called “Advice ordering”. The precedence between aspects is determined by either adding the Orderannotation to the bean backing the aspect or by having the bean implement the Orderedinterface.

11.3.4 Introductions

Introductions (known as inter-type declarations in AspectJ) enable an aspect to declare that advised objects implement a given interface, and to provide an implementation of that interface on behalf of those objects.

An introduction is made using the aop:declare-parentselement inside an aop:aspectThis element is used to declare that matching types have a new parent (hence the name). For example, given an interface UsageTracked, and an implementation of that interface DefaultUsageTracked, the following aspect declares that all implementors of service interfaces also implement the UsageTrackedinterface. (In order to expose statistics via JMX for example.)

								<aop:aspect
								id=
								"usageTrackerAspect"
								ref=
								"usageTracking"
								>
								<aop:declare-parents
								types-matching=
								"com.xzy.myapp.service.*+"
								implement-interface=
								"com.xyz.myapp.service.tracking.UsageTracked"
								default-impl=
								"com.xyz.myapp.service.tracking.DefaultUsageTracked"
								/>
								<aop:before
								pointcut=
								"com.xyz.myapp.SystemArchitecture.businessService() and this(usageTracked)"
								method=
								"recordUsage"
								/>
								</aop:aspect>

The class backing the usageTrackingbean would contain the method:

								public
								voidrecordUsage(UsageTracked usageTracked) { usageTracked.incrementUseCount(); }

The interface to be implemented is determined by implement-interfaceattribute. The value of the types-matchingattribute is an AspectJ type pattern :- any bean of a matching type will implement the UsageTrackedinterface. Note that in the before advice of the above example, service beans can be directly used as implementations of the UsageTrackedinterface. If accessing a bean programmatically you would write the following:

UsageTracked usageTracked = (UsageTracked) context.getBean(
								"myService");

11.3.5 Aspect instantiation models

The only supported instantiation model for schema-defined aspects is the singleton model. Other instantiation models may be supported in future releases.

11.3.6 Advisors

The concept of "advisors" is brought forward from the AOP support defined in Spring 1.2 and does not have a direct equivalent in AspectJ. An advisor is like a small self-contained aspect that has a single piece of advice. The advice itself is represented by a bean, and must implement one of the advice interfaces described in Section 12.3.2, “Advice types in Spring”. Advisors can take advantage of AspectJ pointcut expressions though.

Spring supports the advisor concept with the <aop:advisor>element. You will most commonly see it used in conjunction with transactional advice, which also has its own namespace support in Spring. Here’s how it looks:

								<aop:config>
								<aop:pointcut
								id=
								"businessService"
								expression=
								"execution(* com.xyz.myapp.service.*.*(..))"
								/>
								<aop:advisor
								pointcut-ref=
								"businessService"
								advice-ref=
								"tx-advice"
								/>
								</aop:config>
								<tx:advice
								id=
								"tx-advice"
								>
								<tx:attributes>
								<tx:method
								name=
								"*"
								propagation=
								"REQUIRED"
								/>
								</tx:attributes>
								</tx:advice>

As well as the pointcut-refattribute used in the above example, you can also use the pointcutattribute to define a pointcut expression inline.

To define the precedence of an advisor so that the advice can participate in ordering, use the orderattribute to define the Orderedvalue of the advisor.

11.3.7 Example

Let’s see how the concurrent locking failure retry example from Section 11.2.7, “Example”looks when rewritten using the schema support.

The execution of business services can sometimes fail due to concurrency issues (for example, deadlock loser). If the operation is retried, it is quite likely it will succeed next time round. For business services where it is appropriate to retry in such conditions (idempotent operations that don’t need to go back to the user for conflict resolution), we’d like to transparently retry the operation to avoid the client seeing a PessimisticLockingFailureException. This is a requirement that clearly cuts across multiple services in the service layer, and hence is ideal for implementing via an aspect.

Because we want to retry the operation, we’ll need to use around advice so that we can call proceed multiple times. Here’s how the basic aspect implementation looks (it’s just a regular Java class using the schema support):

								public
								classConcurrentOperationExecutor
								implementsOrdered {
								private
								static
								final
								intDEFAULT_MAX_RETRIES =
								2;
								private
								intmaxRetries = DEFAULT_MAX_RETRIES;
								private
								intorder =
								1;
								public
								voidsetMaxRetries(
								intmaxRetries) {
								this.maxRetries = maxRetries; }
								public
								intgetOrder() {
								return
								this.order; }
								public
								voidsetOrder(
								intorder) {
								this.order = order; }
								publicObject doConcurrentOperation(ProceedingJoinPoint pjp)
								throwsThrowable {
								intnumAttempts =
								0; PessimisticLockingFailureException lockFailureException;
								do{ numAttempts++;
								try{
								returnpjp.proceed(); }
								catch(PessimisticLockingFailureException ex) { lockFailureException = ex; } }
								while(numAttempts <=
								this.maxRetries);
								throwlockFailureException; } }

Note that the aspect implements the Orderedinterface so we can set the precedence of the aspect higher than the transaction advice (we want a fresh transaction each time we retry). The maxRetriesand orderproperties will both be configured by Spring. The main action happens in the doConcurrentOperationaround advice method. We try to proceed, and if we fail with a PessimisticLockingFailureExceptionwe simply try again unless we have exhausted all of our retry attempts.

[Note] Note

This class is identical to the one used in the @AspectJ example, but with the annotations removed.

The corresponding Spring configuration is:

								<aop:config>
								<aop:aspect
								id=
								"concurrentOperationRetry"
								ref=
								"concurrentOperationExecutor"
								>
								<aop:pointcut
								id=
								"idempotentOperation"
								expression=
								"execution(* com.xyz.myapp.service.*.*(..))"
								/>
								<aop:around
								pointcut-ref=
								"idempotentOperation"
								method=
								"doConcurrentOperation"
								/>
								</aop:aspect>
								</aop:config>
								<bean
								id=
								"concurrentOperationExecutor"
								class=
								"com.xyz.myapp.service.impl.ConcurrentOperationExecutor"
								>
								<property
								name=
								"maxRetries"
								value=
								"3"
								/>
								<property
								name=
								"order"
								value=
								"100"
								/>
								</bean>

Notice that for the time being we assume that all business services are idempotent. If this is not the case we can refine the aspect so that it only retries genuinely idempotent operations, by introducing an Idempotentannotation:

								
									@Retention(RetentionPolicy.RUNTIME)
								public
								
									@interfaceIdempotent {
								// marker annotation}

and using the annotation to annotate the implementation of service operations. The change to the aspect to retry only idempotent operations simply involves refining the pointcut expression so that only @Idempotentoperations match:

								<aop:pointcut
								id=
								"idempotentOperation"
								expression=
								"execution(* com.xyz.myapp.service.*.*(..)) and @annotation(com.xyz.myapp.service.Idempotent)"
								/>

11.4 Choosing which AOP declaration style to use

Once you have decided that an aspect is the best approach for implementing a given requirement, how do you decide between using Spring AOP or AspectJ, and between the Aspect language (code) style, @AspectJ annotation style, or the Spring XML style? These decisions are influenced by a number of factors including application requirements, development tools, and team familiarity with AOP.

11.4.1 Spring AOP or full AspectJ?

Use the simplest thing that can work. Spring AOP is simpler than using full AspectJ as there is no requirement to introduce the AspectJ compiler / weaver into your development and build processes. If you only need to advise the execution of operations on Spring beans, then Spring AOP is the right choice. If you need to advise objects not managed by the Spring container (such as domain objects typically), then you will need to use AspectJ. You will also need to use AspectJ if you wish to advise join points other than simple method executions (for example, field get or set join points, and so on).

When using AspectJ, you have the choice of the AspectJ language syntax (also known as the "code style") or the @AspectJ annotation style. Clearly, if you are not using Java 5+ then the choice has been made for you…​ use the code style. If aspects play a large role in your design, and you are able to use the AspectJ Development Tools (AJDT)plugin for Eclipse, then the AspectJ language syntax is the preferred option: it is cleaner and simpler because the language was purposefully designed for writing aspects. If you are not using Eclipse, or have only a few aspects that do not play a major role in your application, then you may want to consider using the @AspectJ style and sticking with a regular Java compilation in your IDE, and adding an aspect weaving phase to your build script.

11.4.2 @AspectJ or XML for Spring AOP?

If you have chosen to use Spring AOP, then you have a choice of @AspectJ or XML style. There are various tradeoffs to consider.

The XML style will be most familiar to existing Spring users and it is backed by genuine POJOs. When using AOP as a tool to configure enterprise services then XML can be a good choice (a good test is whether you consider the pointcut expression to be a part of your configuration you might want to change independently). With the XML style arguably it is clearer from your configuration what aspects are present in the system.

The XML style has two disadvantages. Firstly it does not fully encapsulate the implementation of the requirement it addresses in a single place. The DRY principle says that there should be a single, unambiguous, authoritative representation of any piece of knowledge within a system. When using the XML style, the knowledge of howa requirement is implemented is split across the declaration of the backing bean class, and the XML in the configuration file. When using the @AspectJ style there is a single module - the aspect - in which this information is encapsulated. Secondly, the XML style is slightly more limited in what it can express than the @AspectJ style: only the "singleton" aspect instantiation model is supported, and it is not possible to combine named pointcuts declared in XML. For example, in the @AspectJ style you can write something like:

								
									@Pointcut(execution(* get*()))
								public
								voidpropertyAccess() {} @Pointcut(execution(org.xyz.Account+ *(..))
								public
								voidoperationReturningAnAccount() {}
								
									@Pointcut(propertyAccess() && operationReturningAnAccount())
								public
								voidaccountPropertyAccess() {}

In the XML style I can declare the first two pointcuts:

								<aop:pointcut
								id=
								"propertyAccess"
								expression=
								"execution(* get*())"
								/>
								<aop:pointcut
								id=
								"operationReturningAnAccount"
								expression=
								"execution(org.xyz.Account+ *(..))"
								/>

The downside of the XML approach is that you cannot define the accountPropertyAccesspointcut by combining these definitions.

The @AspectJ style supports additional instantiation models, and richer pointcut composition. It has the advantage of keeping the aspect as a modular unit. It also has the advantage the @AspectJ aspects can be understood (and thus consumed) both by Spring AOP and by AspectJ - so if you later decide you need the capabilities of AspectJ to implement additional requirements then it is very easy to migrate to an AspectJ-based approach. On balance the Spring team prefer the @AspectJ style whenever you have aspects that do more than simple "configuration" of enterprise services.

11.5 Mixing aspect types

It is perfectly possible to mix @AspectJ style aspects using the autoproxying support, schema-defined <aop:aspect>aspects, <aop:advisor>declared advisors and even proxies and interceptors defined using the Spring 1.2 style in the same configuration. All of these are implemented using the same underlying support mechanism and will co-exist without any difficulty.

11.6 Proxying mechanisms

Spring AOP uses either JDK dynamic proxies or CGLIB to create the proxy for a given target object. (JDK dynamic proxies are preferred whenever you have a choice).

If the target object to be proxied implements at least one interface then a JDK dynamic proxy will be used. All of the interfaces implemented by the target type will be proxied. If the target object does not implement any interfaces then a CGLIB proxy will be created.

If you want to force the use of CGLIB proxying (for example, to proxy every method defined for the target object, not just those implemented by its interfaces) you can do so. However, there are some issues to consider:

  • finalmethods cannot be advised, as they cannot be overridden.
  • As of Spring 3.2, it is no longer necessary to add CGLIB to your project classpath, as CGLIB classes are repackaged under org.springframework and included directly in the spring-core JAR. This means that CGLIB-based proxy support 'just works' in the same way that JDK dynamic proxies always have.
  • As of Spring 4.0, the constructor of your proxied object will NOT be called twice anymore since the CGLIB proxy instance will be created via Objenesis. Only if your JVM does not allow for constructor bypassing, you might see double invocations and corresponding debug log entries from Spring’s AOP support.

To force the use of CGLIB proxies set the value of the proxy-target-classattribute of the <aop:config>element to true:

							<aop:config
							proxy-target-class=
							"true"
							>
							<!-- other beans defined here... -->
							</aop:config>

To force CGLIB proxying when using the @AspectJ autoproxy support, set the 'proxy-target-class'attribute of the <aop:aspectj-autoproxy>element to true:

							<aop:aspectj-autoproxy
							proxy-target-class=
							"true"
							/>
[Note] Note

Multiple <aop:config/>sections are collapsed into a single unified auto-proxy creator at runtime, which applies the strongestproxy settings that any of the <aop:config/>sections (typically from different XML bean definition files) specified. This also applies to the <tx:annotation-driven/>and <aop:aspectj-autoproxy/>elements.

To be clear: using proxy-target-class="true"on <tx:annotation-driven/>, <aop:aspectj-autoproxy/>or <aop:config/>elements will force the use of CGLIB proxies for all three of them.

11.6.1 Understanding AOP proxies

Spring AOP is proxy-based. It is vitally important that you grasp the semantics of what that last statement actually means before you write your own aspects or use any of the Spring AOP-based aspects supplied with the Spring Framework.

Consider first the scenario where you have a plain-vanilla, un-proxied, nothing-special-about-it, straight object reference, as illustrated by the following code snippet.

								public
								classSimplePojo
								implementsPojo {
								public
								voidfoo() {
								// this next method invocation is a direct call on the 'this' reference
								this.bar(); }
								public
								voidbar() {
								// some logic...} }

If you invoke a method on an object reference, the method is invoked directlyon that object reference, as can be seen below.

aop proxy plain pojo call
								public
								classMain {
								public
								static
								voidmain(String[] args) { Pojo pojo =
								newSimplePojo();
								// this is a direct method call on the 'pojo' referencepojo.foo(); } }

Things change slightly when the reference that client code has is a proxy. Consider the following diagram and code snippet.

aop proxy call
								public
								classMain {
								public
								static
								voidmain(String[] args) { ProxyFactory factory =
								newProxyFactory(
								newSimplePojo()); factory.addInterface(Pojo.
								class); factory.addAdvice(
								newRetryAdvice()); Pojo pojo = (Pojo) factory.getProxy();
								// this is a method call on the proxy!pojo.foo(); } }

The key thing to understand here is that the client code inside the main(..)of the Mainclass has a reference to the proxy. This means that method calls on that object reference will be calls on the proxy, and as such the proxy will be able to delegate to all of the interceptors (advice) that are relevant to that particular method call. However, once the call has finally reached the target object, the SimplePojoreference in this case, any method calls that it may make on itself, such as this.bar()or this.foo(), are going to be invoked against the thisreference, and notthe proxy. This has important implications. It means that self-invocation is notgoing to result in the advice associated with a method invocation getting a chance to execute.

Okay, so what is to be done about this? The best approach (the term best is used loosely here) is to refactor your code such that the self-invocation does not happen. For sure, this does entail some work on your part, but it is the best, least-invasive approach. The next approach is absolutely horrendous, and I am almost reticent to point it out precisely because it is so horrendous. You can (choke!) totally tie the logic within your class to Spring AOP by doing this:

								public
								classSimplePojo
								implementsPojo {
								public
								voidfoo() {
								// this works, but... gah!((Pojo) AopContext.currentProxy()).bar(); }
								public
								voidbar() {
								// some logic...} }

This totally couples your code to Spring AOP, andit makes the class itself aware of the fact that it is being used in an AOP context, which flies in the face of AOP. It also requires some additional configuration when the proxy is being created:

								public
								classMain {
								public
								static
								voidmain(String[] args) { ProxyFactory factory =
								newProxyFactory(
								newSimplePojo()); factory.adddInterface(Pojo.
								class); factory.addAdvice(
								newRetryAdvice()); factory.setExposeProxy(true); Pojo pojo = (Pojo) factory.getProxy();
								// this is a method call on the proxy!pojo.foo(); } }

Finally, it must be noted that AspectJ does not have this self-invocation issue because it is not a proxy-based AOP framework.

11.7 Programmatic creation of @AspectJ Proxies

In addition to declaring aspects in your configuration using either <aop:config>or <aop:aspectj-autoproxy>, it is also possible programmatically to create proxies that advise target objects. For the full details of Spring’s AOP API, see the next chapter. Here we want to focus on the ability to automatically create proxies using @AspectJ aspects.

The class org.springframework.aop.aspectj.annotation.AspectJProxyFactorycan be used to create a proxy for a target object that is advised by one or more @AspectJ aspects. Basic usage for this class is very simple, as illustrated below. See the javadocs for full information.

							// create a factory that can generate a proxy for the given target objectAspectJProxyFactory factory =
							newAspectJProxyFactory(targetObject);
							// add an aspect, the class must be an @AspectJ aspect
							// you can call this as many times as you need with different aspectsfactory.addAspect(SecurityManager.
							class);
							// you can also add existing aspect instances, the type of the object supplied must be an @AspectJ aspectfactory.addAspect(usageTracker);
							// now get the proxy object...MyInterfaceType proxy = factory.getProxy();

11.8 Using AspectJ with Spring applications

Everything we’ve covered so far in this chapter is pure Spring AOP. In this section, we’re going to look at how you can use the AspectJ compiler/weaver instead of, or in addition to, Spring AOP if your needs go beyond the facilities offered by Spring AOP alone.

Spring ships with a small AspectJ aspect library, which is available standalone in your distribution as spring-aspects.jar; you’ll need to add this to your classpath in order to use the aspects in it. Section 11.8.1, “Using AspectJ to dependency inject domain objects with Spring”and Section 11.8.2, “Other Spring aspects for AspectJ”discuss the content of this library and how you can use it. Section 11.8.3, “Configuring AspectJ aspects using Spring IoC”discusses how to dependency inject AspectJ aspects that are woven using the AspectJ compiler. Finally, Section 11.8.4, “Load-time weaving with AspectJ in the Spring Framework”provides an introduction to load-time weaving for Spring applications using AspectJ.

11.8.1 Using AspectJ to dependency inject domain objects with Spring

The Spring container instantiates and configures beans defined in your application context. It is also possible to ask a bean factory to configure a pre-existingobject given the name of a bean definition containing the configuration to be applied. The spring-aspects.jarcontains an annotation-driven aspect that exploits this capability to allow dependency injection of any object. The support is intended to be used for objects created outside of the control of any container. Domain objects often fall into this category because they are often created programmatically using the newoperator, or by an ORM tool as a result of a database query.

The @Configurableannotation marks a class as eligible for Spring-driven configuration. In the simplest case it can be used just as a marker annotation:

								packagecom.xyz.myapp.domain;
								importorg.springframework.beans.factory.annotation.Configurable;
								
									@Configurable
								public
								classAccount {
								// ...}

When used as a marker interface in this way, Spring will configure new instances of the annotated type ( Accountin this case) using a bean definition (typically prototype-scoped) with the same name as the fully-qualified type name ( com.xyz.myapp.domain.Account). Since the default name for a bean is the fully-qualified name of its type, a convenient way to declare the prototype definition is simply to omit the idattribute:

								<bean
								class=
								"com.xyz.myapp.domain.Account"
								scope=
								"prototype"
								>
								<property
								name=
								"fundsTransferService"
								ref=
								"fundsTransferService"
								/>
								</bean>

If you want to explicitly specify the name of the prototype bean definition to use, you can do so directly in the annotation:

								packagecom.xyz.myapp.domain;
								importorg.springframework.beans.factory.annotation.Configurable;
								
									@Configurable("account")
								public
								classAccount {
								// ...}

Spring will now look for a bean definition named "account" and use that as the definition to configure new Accountinstances.

You can also use autowiring to avoid having to specify a dedicated bean definition at all. To have Spring apply autowiring use the autowireproperty of the @Configurableannotation: specify either @Configurable(autowire=Autowire.BY_TYPE)or @Configurable(autowire=Autowire.BY_NAMEfor autowiring by type or by name respectively. As an alternative, as of Spring 2.5 it is preferable to specify explicit, annotation-driven dependency injection for your @Configurablebeans by using @Autowiredor @Injectat the field or method level (see Section 7.9, “Annotation-based container configuration”for further details).

Finally you can enable Spring dependency checking for the object references in the newly created and configured object by using the dependencyCheckattribute (for example: @Configurable(autowire=Autowire.BY_NAME,dependencyCheck=true)). If this attribute is set to true, then Spring will validate after configuration that all properties ( which are not primitives or collections) have been set.

Using the annotation on its own does nothing of course. It is the AnnotationBeanConfigurerAspectin spring-aspects.jarthat acts on the presence of the annotation. In essence the aspect says "after returning from the initialization of a new object of a type annotated with @Configurable, configure the newly created object using Spring in accordance with the properties of the annotation". In this context, initializationrefers to newly instantiated objects (e.g., objects instantiated with the newoperator) as well as to Serializableobjects that are undergoing deserialization (e.g., via readResolve()).

[Note] Note

One of the key phrases in the above paragraph is ' in essence'. For most cases, the exact semantics of ' after returning from the initialization of a new object' will be fine…​ in this context, ' after initialization' means that the dependencies will be injected afterthe object has been constructed - this means that the dependencies will not be available for use in the constructor bodies of the class. If you want the dependencies to be injected beforethe constructor bodies execute, and thus be available for use in the body of the constructors, then you need to define this on the @Configurabledeclaration like so:

@Configurable(preConstruction=true)

You can find out more information about the language semantics of the various pointcut types in AspectJ in this appendixof the AspectJ Programming Guide.

For this to work the annotated types must be woven with the AspectJ weaver - you can either use a build-time Ant or Maven task to do this (see for example the AspectJ Development Environment Guide) or load-time weaving (see Section 11.8.4, “Load-time weaving with AspectJ in the Spring Framework”). The AnnotationBeanConfigurerAspectitself needs configuring by Spring (in order to obtain a reference to the bean factory that is to be used to configure new objects). If you are using Java based configuration simply add @EnableSpringConfiguredto any @Configurationclass.

								
									@Configuration
								
									@EnableSpringConfigured
								public
								classAppConfig { }

If you prefer XML based configuration, the Spring contextnamespacedefines a convenient context:spring-configuredelement:

								<context:spring-configured/>

Instances of @Configurableobjects created beforethe aspect has been configured will result in a message being issued to the debug log and no configuration of the object taking place. An example might be a bean in the Spring configuration that creates domain objects when it is initialized by Spring. In this case you can use the "depends-on" bean attribute to manually specify that the bean depends on the configuration aspect.

								<bean
								id=
								"myService"
								class=
								"com.xzy.myapp.service.MyService"
								depends-on=
								"org.springframework.beans.factory.aspectj.AnnotationBeanConfigurerAspect"
								>
								<!-- ... -->
								</bean>
[Note] Note

Do not activate @Configurableprocessing through the bean configurer aspect unless you really mean to rely on its semantics at runtime. In particular, make sure that you do not use @Configurableon bean classes which are registered as regular Spring beans with the container: You would get double initialization otherwise, once through the container and once through the aspect.

Unit testing @Configurable objects

One of the goals of the @Configurablesupport is to enable independent unit testing of domain objects without the difficulties associated with hard-coded lookups. If @Configurabletypes have not been woven by AspectJ then the annotation has no affect during unit testing, and you can simply set mock or stub property references in the object under test and proceed as normal. If @Configurabletypes havebeen woven by AspectJ then you can still unit test outside of the container as normal, but you will see a warning message each time that you construct an @Configurableobject indicating that it has not been configured by Spring.

Working with multiple application contexts

The AnnotationBeanConfigurerAspectused to implement the @Configurablesupport is an AspectJ singleton aspect. The scope of a singleton aspect is the same as the scope of staticmembers, that is to say there is one aspect instance per classloader that defines the type. This means that if you define multiple application contexts within the same classloader hierarchy you need to consider where to define the @EnableSpringConfiguredbean and where to place spring-aspects.jaron the classpath.

Consider a typical Spring web-app configuration with a shared parent application context defining common business services and everything needed to support them, and one child application context per servlet containing definitions particular to that servlet. All of these contexts will co-exist within the same classloader hierarchy, and so the AnnotationBeanConfigurerAspectcan only hold a reference to one of them. In this case we recommend defining the @EnableSpringConfiguredbean in the shared (parent) application context: this defines the services that you are likely to want to inject into domain objects. A consequence is that you cannot configure domain objects with references to beans defined in the child (servlet-specific) contexts using the @Configurable mechanism (probably not something you want to do anyway!).

When deploying multiple web-apps within the same container, ensure that each web-application loads the types in spring-aspects.jarusing its own classloader (for example, by placing spring-aspects.jarin 'WEB-INF/lib'). If spring-aspects.jaris only added to the container wide classpath (and hence loaded by the shared parent classloader), all web applications will share the same aspect instance which is probably not what you want.

11.8.2 Other Spring aspects for AspectJ

In addition to the @Configurableaspect, spring-aspects.jarcontains an AspectJ aspect that can be used to drive Spring’s transaction management for types and methods annotated with the @Transactionalannotation. This is primarily intended for users who want to use the Spring Framework’s transaction support outside of the Spring container.

The aspect that interprets @Transactionalannotations is the AnnotationTransactionAspect. When using this aspect, you must annotate the implementationclass (and/or methods within that class), notthe interface (if any) that the class implements. AspectJ follows Java’s rule that annotations on interfaces are not inherited.

A @Transactionalannotation on a class specifies the default transaction semantics for the execution of any publicoperation in the class.

A @Transactionalannotation on a method within the class overrides the default transaction semantics given by the class annotation (if present). Methods of any visibility may be annotated, including private methods. Annotating non-public methods directly is the only way to get transaction demarcation for the execution of such methods.

[Tip] Tip

Since Spring Framework 4.2, spring-aspectsprovides a similar aspect that offers the exact same features for the standard javax.transaction.Transactionalannotation. Check JtaAnnotationTransactionAspectfor more details.

For AspectJ programmers that want to use the Spring configuration and transaction management support but don’t want to (or cannot) use annotations, spring-aspects.jaralso contains abstractaspects you can extend to provide your own pointcut definitions. See the sources for the AbstractBeanConfigurerAspectand AbstractTransactionAspectaspects for more information. As an example, the following excerpt shows how you could write an aspect to configure all instances of objects defined in the domain model using prototype bean definitions that match the fully-qualified class names:

								publicaspect DomainObjectConfiguration
								extendsAbstractBeanConfigurerAspect {
								publicDomainObjectConfiguration() { setBeanWiringInfoResolver(
								newClassNameBeanWiringInfoResolver()); }
								// the creation of a new bean (any object in the domain model)
								protectedpointcut beanCreation(Object beanInstance) : initialization(
								new(..)) && SystemArchitecture.inDomainModel() &&
								this(beanInstance); }

11.8.3 Configuring AspectJ aspects using Spring IoC

When using AspectJ aspects with Spring applications, it is natural to both want and expect to be able to configure such aspects using Spring. The AspectJ runtime itself is responsible for aspect creation, and the means of configuring the AspectJ created aspects via Spring depends on the AspectJ instantiation model (the per-xxxclause) used by the aspect.

The majority of AspectJ aspects are singletonaspects. Configuration of these aspects is very easy: simply create a bean definition referencing the aspect type as normal, and include the bean attribute 'factory-method="aspectOf"'. This ensures that Spring obtains the aspect instance by asking AspectJ for it rather than trying to create an instance itself. For example:

								<bean
								id=
								"profiler"
								class=
								"com.xyz.profiler.Profiler"
								
									factory-method="aspectOf">
								<property
								name=
								"profilingStrategy"
								ref=
								"jamonProfilingStrategy"
								/>
								</bean>

Non-singleton aspects are harder to configure: however it is possible to do so by creating prototype bean definitions and using the @Configurablesupport from spring-aspects.jarto configure the aspect instances once they have bean created by the AspectJ runtime.

If you have some @AspectJ aspects that you want to weave with AspectJ (for example, using load-time weaving for domain model types) and other @AspectJ aspects that you want to use with Spring AOP, and these aspects are all configured using Spring, then you will need to tell the Spring AOP @AspectJ autoproxying support which exact subset of the @AspectJ aspects defined in the configuration should be used for autoproxying. You can do this by using one or more <include/>elements inside the <aop:aspectj-autoproxy/>declaration. Each <include/>element specifies a name pattern, and only beans with names matched by at least one of the patterns will be used for Spring AOP autoproxy configuration:

								<aop:aspectj-autoproxy>
								<aop:include
								name=
								"thisBean"
								/>
								<aop:include
								name=
								"thatBean"
								/>
								</aop:aspectj-autoproxy>
[Note] Note

Do not be misled by the name of the <aop:aspectj-autoproxy/>element: using it will result in the creation of Spring AOP proxies. The @AspectJ style of aspect declaration is just being used here, but the AspectJ runtime is notinvolved.

11.8.4 Load-time weaving with AspectJ in the Spring Framework

Load-time weaving (LTW) refers to the process of weaving AspectJ aspects into an application’s class files as they are being loaded into the Java virtual machine (JVM). The focus of this section is on configuring and using LTW in the specific context of the Spring Framework: this section is not an introduction to LTW though. For full details on the specifics of LTW and configuring LTW with just AspectJ (with Spring not being involved at all), see the LTW section of the AspectJ Development Environment Guide.

The value-add that the Spring Framework brings to AspectJ LTW is in enabling much finer-grained control over the weaving process. 'Vanilla' AspectJ LTW is effected using a Java (5+) agent, which is switched on by specifying a VM argument when starting up a JVM. It is thus a JVM-wide setting, which may be fine in some situations, but often is a little too coarse. Spring-enabled LTW enables you to switch on LTW on a per-ClassLoaderbasis, which obviously is more fine-grained and which can make more sense in a 'single-JVM-multiple-application' environment (such as is found in a typical application server environment).

Further, in certain environments, this support enables load-time weaving without making any modifications to the application server’s launch scriptthat will be needed to add -javaagent:path/to/aspectjweaver.jaror (as we describe later in this section) -javaagent:path/to/org.springframework.instrument-{version}.jar(previously named spring-agent.jar). Developers simply modify one or more files that form the application context to enable load-time weaving instead of relying on administrators who typically are in charge of the deployment configuration such as the launch script.

Now that the sales pitch is over, let us first walk through a quick example of AspectJ LTW using Spring, followed by detailed specifics about elements introduced in the following example. For a complete example, please see the Petclinic sample application.

A first example

Let us assume that you are an application developer who has been tasked with diagnosing the cause of some performance problems in a system. Rather than break out a profiling tool, what we are going to do is switch on a simple profiling aspect that will enable us to very quickly get some performance metrics, so that we can then apply a finer-grained profiling tool to that specific area immediately afterwards.

[Note] Note

The example presented here uses XML style configuration, it is also possible to configure and use @AspectJ with Java Configuration. Specifically the @EnableLoadTimeWeavingannotation can be used as an alternative to <context:load-time-weaver/>(see belowfor details).

Here is the profiling aspect. Nothing too fancy, just a quick-and-dirty time-based profiler, using the @AspectJ-style of aspect declaration.

									packagefoo;
									importorg.aspectj.lang.ProceedingJoinPoint;
									importorg.aspectj.lang.annotation.Aspect;
									importorg.aspectj.lang.annotation.Around;
									importorg.aspectj.lang.annotation.Pointcut;
									importorg.springframework.util.StopWatch;
									importorg.springframework.core.annotation.Order;
									
										@Aspect
									public
									classProfilingAspect {
									
										@Around("methodsToBeProfiled()")
									publicObject profile(ProceedingJoinPoint pjp)
									throwsThrowable { StopWatch sw =
									newStopWatch(getClass().getSimpleName());
									try{ sw.start(pjp.getSignature().getName());
									returnpjp.proceed(); }
									finally{ sw.stop(); System.out.println(sw.prettyPrint()); } }
									
										@Pointcut("execution(public * foo..*.*(..))")
									public
									voidmethodsToBeProfiled(){} }

We will also need to create an META-INF/aop.xmlfile, to inform the AspectJ weaver that we want to weave our ProfilingAspectinto our classes. This file convention, namely the presence of a file (or files) on the Java classpath called META-INF/aop.xmlis standard AspectJ.

									<!DOCTYPE aspectj PUBLIC "-//AspectJ//DTD//EN" "http://www.eclipse.org/aspectj/dtd/aspectj.dtd">
									<aspectj>
									<weaver>
									<!-- only weave classes in our application-specific packages -->
									<include
									within=
									"foo.*"
									/>
									</weaver>
									<aspects>
									<!-- weave in just this aspect -->
									<aspect
									name=
									"foo.ProfilingAspect"
									/>
									</aspects>
									</aspectj>

Now to the Spring-specific portion of the configuration. We need to configure a LoadTimeWeaver(all explained later, just take it on trust for now). This load-time weaver is the essential component responsible for weaving the aspect configuration in one or more META-INF/aop.xmlfiles into the classes in your application. The good thing is that it does not require a lot of configuration, as can be seen below (there are some more options that you can specify, but these are detailed later).

									<?xml version="1.0" encoding="UTF-8"?>
									<beans
									xmlns=
									"http://www.springframework.org/schema/beans"
									xmlns:xsi=
									"http://www.w3.org/2001/XMLSchema-instance"
									xmlns:context=
									"http://www.springframework.org/schema/context"
									xsi:schemaLocation=
									" http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd"
									>
									<!-- a service object; we will be profiling its methods -->
									<bean
									id=
									"entitlementCalculationService"
									class=
									"foo.StubEntitlementCalculationService"
									/>
									<!-- this switches on the load-time weaving -->
									
										<context:load-time-weaver/>
									</beans>

Now that all the required artifacts are in place - the aspect, the META-INF/aop.xmlfile, and the Spring configuration -, let us create a simple driver class with a main(..)method to demonstrate the LTW in action.

									packagefoo;
									importorg.springframework.context.support.ClassPathXmlApplicationContext;
									public
									final
									classMain {
									public
									static
									voidmain(String[] args) { ApplicationContext ctx =
									newClassPathXmlApplicationContext(
									"beans.xml", Main.
									class); EntitlementCalculationService entitlementCalculationService = (EntitlementCalculationService) ctx.getBean(
									"entitlementCalculationService");
									// the profiling aspect is 'woven' around this method executionentitlementCalculationService.calculateEntitlement(); } }

There is one last thing to do. The introduction to this section did say that one could switch on LTW selectively on a per- ClassLoaderbasis with Spring, and this is true. However, just for this example, we are going to use a Java agent (supplied with Spring) to switch on the LTW. This is the command line we will use to run the above Mainclass:

java -javaagent:C:/projects/foo/lib/global/spring-instrument.jar foo.Main

The -javaagentis a flag for specifying and enabling agents to instrument programs running on the JVM. The Spring Framework ships with such an agent, the InstrumentationSavingAgent, which is packaged in the spring-instrument.jarthat was supplied as the value of the -javaagentargument in the above example.

The output from the execution of the Mainprogram will look something like that below. (I have introduced a Thread.sleep(..)statement into the calculateEntitlement()implementation so that the profiler actually captures something other than 0 milliseconds - the 01234milliseconds is notan overhead introduced by the AOP :) )

Calculating entitlement StopWatch 'ProfilingAspect': running time (millis) = 1234 ------ ----- ---------------------------- ms % Task name ------ ----- ---------------------------- 01234 100% calculateEntitlement

Since this LTW is effected using full-blown AspectJ, we are not just limited to advising Spring beans; the following slight variation on the Mainprogram will yield the same result.

									packagefoo;
									importorg.springframework.context.support.ClassPathXmlApplicationContext;
									public
									final
									classMain {
									public
									static
									voidmain(String[] args) {
									newClassPathXmlApplicationContext(
									"beans.xml", Main.
									class); EntitlementCalculationService entitlementCalculationService =
									newStubEntitlementCalculationService();
									// the profiling aspect will be 'woven' around this method executionentitlementCalculationService.calculateEntitlement(); } }

Notice how in the above program we are simply bootstrapping the Spring container, and then creating a new instance of the StubEntitlementCalculationServicetotally outside the context of Spring…​ the profiling advice still gets woven in.

The example admittedly is simplistic…​ however the basics of the LTW support in Spring have all been introduced in the above example, and the rest of this section will explain the 'why' behind each bit of configuration and usage in detail.

[Note] Note

The ProfilingAspectused in this example may be basic, but it is quite useful. It is a nice example of a development-time aspect that developers can use during development (of course), and then quite easily exclude from builds of the application being deployed into UAT or production.

Aspects

The aspects that you use in LTW have to be AspectJ aspects. They can be written in either the AspectJ language itself or you can write your aspects in the @AspectJ-style. It means that your aspects are then both valid AspectJ andSpring AOP aspects. Furthermore, the compiled aspect classes need to be available on the classpath.

'META-INF/aop.xml'

The AspectJ LTW infrastructure is configured using one or more META-INF/aop.xmlfiles, that are on the Java classpath (either directly, or more typically in jar files).

The structure and contents of this file is detailed in the main AspectJ reference documentation, and the interested reader is referred to that resource. (I appreciate that this section is brief, but the aop.xmlfile is 100% AspectJ - there is no Spring-specific information or semantics that apply to it, and so there is no extra value that I can contribute either as a result), so rather than rehash the quite satisfactory section that the AspectJ developers wrote, I am just directing you there.)

Required libraries (JARS)

At a minimum you will need the following libraries to use the Spring Framework’s support for AspectJ LTW:

  • spring-aop.jar(version 2.5 or later, plus all mandatory dependencies)
  • aspectjweaver.jar(version 1.6.8 or later)

If you are using the Spring-provided agent to enable instrumentation, you will also need:

  • spring-instrument.jar

Spring configuration

The key component in Spring’s LTW support is the LoadTimeWeaverinterface (in the org.springframework.instrument.classloadingpackage), and the numerous implementations of it that ship with the Spring distribution. A LoadTimeWeaveris responsible for adding one or more java.lang.instrument.ClassFileTransformersto a ClassLoaderat runtime, which opens the door to all manner of interesting applications, one of which happens to be the LTW of aspects.

[Tip] Tip

If you are unfamiliar with the idea of runtime class file transformation, you are encouraged to read the javadoc API documentation for the java.lang.instrumentpackage before continuing. This is not a huge chore because there is - rather annoyingly - precious little documentation there…​ the key interfaces and classes will at least be laid out in front of you for reference as you read through this section.

Configuring a LoadTimeWeaverfor a particular ApplicationContextcan be as easy as adding one line. (Please note that you almost certainly will need to be using an ApplicationContextas your Spring container - typically a BeanFactorywill not be enough because the LTW support makes use of BeanFactoryPostProcessors.)

To enable the Spring Framework’s LTW support, you need to configure a LoadTimeWeaver, which typically is done using the @EnableLoadTimeWeavingannotation.

									
										@Configuration
									
										@EnableLoadTimeWeaving
									public
									classAppConfig { }

Alternatively, if you prefer XML based configuration, use the <context:load-time-weaver/>element. Note that the element is defined in the contextnamespace.

									<?xml version="1.0" encoding="UTF-8"?>
									<beans
									xmlns=
									"http://www.springframework.org/schema/beans"
									xmlns:xsi=
									"http://www.w3.org/2001/XMLSchema-instance"
									xmlns:context=
									"http://www.springframework.org/schema/context"
									xsi:schemaLocation=
									" http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd"
									>
									<context:load-time-weaver/>
									</beans>

The above configuration will define and register a number of LTW-specific infrastructure beans for you automatically, such as a LoadTimeWeaverand an AspectJWeavingEnabler. The default LoadTimeWeaveris the DefaultContextLoadTimeWeaverclass, which attempts to decorate an automatically detected LoadTimeWeaver: the exact type of LoadTimeWeaverthat will be 'automatically detected' is dependent upon your runtime environment (summarized in the following table).

Table 11.1. DefaultContextLoadTimeWeaver LoadTimeWeavers

Runtime Environment LoadTimeWeaverimplementation

Running in Oracle’s WebLogic

WebLogicLoadTimeWeaver

Running in Oracle’s GlassFish

GlassFishLoadTimeWeaver

Running in Apache Tomcat

TomcatLoadTimeWeaver

Running in Red Hat’s JBoss ASor WildFly

JBossLoadTimeWeaver

Running in IBM’s WebSphere

WebSphereLoadTimeWeaver

JVM started with Spring InstrumentationSavingAgent (java -javaagent:path/to/spring-instrument.jar)

InstrumentationLoadTimeWeaver

Fallback, expecting the underlying ClassLoader to follow common conventions (e.g. applicable to TomcatInstrumentableClassLoaderand Resin)

ReflectiveLoadTimeWeaver

Note that these are just the LoadTimeWeaversthat are autodetected when using the DefaultContextLoadTimeWeaver: it is of course possible to specify exactly which LoadTimeWeaverimplementation that you wish to use.

To specify a specific LoadTimeWeaverwith Java configuration implement the LoadTimeWeavingConfigurerinterface and override the getLoadTimeWeaver()method:

									
										@Configuration
									
										@EnableLoadTimeWeaving
									public
									classAppConfig
									implementsLoadTimeWeavingConfigurer {
									
										@Override
									publicLoadTimeWeaver getLoadTimeWeaver() {
									return
									newReflectiveLoadTimeWeaver(); } }

If you are using XML based configuration you can specify the fully-qualified classname as the value of the weaver-classattribute on the <context:load-time-weaver/>element:

									<?xml version="1.0" encoding="UTF-8"?>
									<beans
									xmlns=
									"http://www.springframework.org/schema/beans"
									xmlns:xsi=
									"http://www.w3.org/2001/XMLSchema-instance"
									xmlns:context=
									"http://www.springframework.org/schema/context"
									xsi:schemaLocation=
									" http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd"
									>
									<context:load-time-weaver
									weaver-class=
									"org.springframework.instrument.classloading.ReflectiveLoadTimeWeaver"
									/>
									</beans>

The LoadTimeWeaverthat is defined and registered by the configuration can be later retrieved from the Spring container using the well-known name loadTimeWeaver. Remember that the LoadTimeWeaverexists just as a mechanism for Spring’s LTW infrastructure to add one or more ClassFileTransformers. The actual ClassFileTransformerthat does the LTW is the ClassPreProcessorAgentAdapter(from the org.aspectj.weaver.loadtimepackage) class. See the class-level javadocs of the ClassPreProcessorAgentAdapterclass for further details, because the specifics of how the weaving is actually effected is beyond the scope of this section.

There is one final attribute of the configuration left to discuss: the aspectjWeavingattribute (or aspectj-weavingif you are using XML). This is a simple attribute that controls whether LTW is enabled or not; it is as simple as that. It accepts one of three possible values, summarized below, with the default value being autodetectif the attribute is not present.

Table 11.2. AspectJ weaving attribute values

Annotation Value XML Value Explanation

ENABLED

on

AspectJ weaving is on, and aspects will be woven at load-time as appropriate.

DISABLED

off

LTW is off…​ no aspect will be woven at load-time.

AUTODETECT

autodetect

If the Spring LTW infrastructure can find at least one META-INF/aop.xmlfile, then AspectJ weaving is on, else it is off. This is the default value.

Environment-specific configuration

This last section contains any additional settings and configuration that you will need when using Spring’s LTW support in environments such as application servers and web containers.

Tomcat

Historically, Apache Tomcat's default class loader did not support class transformation which is why Spring provides an enhanced implementation that addresses this need. Named TomcatInstrumentableClassLoader, the loader works on Tomcat 6.0 and above.

[Tip] Tip

Do not define TomcatInstrumentableClassLoaderanymore on Tomcat 8.0 and higher. Instead, let Spring automatically use Tomcat’s new native InstrumentableClassLoaderfacility through the TomcatLoadTimeWeaverstrategy.

If you still need to use TomcatInstrumentableClassLoader, it can be registered individually for eachweb application as follows:

  • Copy org.springframework.instrument.tomcat.jarinto $CATALINA_HOME/lib, where $CATALINA_HOMErepresents the root of the Tomcat installation)
  • Instruct Tomcat to use the custom class loader (instead of the default) by editing the web application context file:
										<Context
										path=
										"/myWebApp"
										docBase=
										"/my/webApp/location"
										>
										<Loader
										loaderClass=
										"org.springframework.instrument.classloading.tomcat.TomcatInstrumentableClassLoader"
										/>
										</Context>

Apache Tomcat (6.0+) supports several context locations:

  • server configuration file - $CATALINA_HOME/conf/server.xml
  • default context configuration - $CATALINA_HOME/conf/context.xml- that affects all deployed web applications
  • per-web application configuration which can be deployed either on the server-side at $CATALINA_HOME/conf/[enginename]/[hostname]/[webapp]-context.xmlor embedded inside the web-app archive at META-INF/context.xml

For efficiency, the embedded per-web-app configuration style is recommended because it will impact only applications that use the custom class loader and does not require any changes to the server configuration. See the Tomcat 6.0.x documentationfor more details about available context locations.

Alternatively, consider the use of the Spring-provided generic VM agent, to be specified in Tomcat’s launch script (see above). This will make instrumentation available to all deployed web applications, no matter what ClassLoader they happen to run on.

WebLogic, WebSphere, Resin, GlassFish, JBoss

Recent versions of WebLogic Server (version 10 and above), IBM WebSphere Application Server (version 7 and above), Resin (3.1 and above) and JBoss (6.x or above) provide a ClassLoader that is capable of local instrumentation. Spring’s native LTW leverages such ClassLoaders to enable AspectJ weaving. You can enable LTW by simply activating load-time weaving as described earlier. Specifically, you do notneed to modify the launch script to add -javaagent:path/to/spring-instrument.jar.

Note that GlassFish instrumentation-capable ClassLoader is available only in its EAR environment. For GlassFish web applications, follow the Tomcat setup instructions as outlined above.

Note that on JBoss 6.x, the app server scanning needs to be disabled to prevent it from loading the classes before the application actually starts. A quick workaround is to add to your artifact a file named WEB-INF/jboss-scanning.xmlwith the following content:

										<scanning
										xmlns=
										"urn:jboss:scanning:1.0"
										/>
Generic Java applications

When class instrumentation is required in environments that do not support or are not supported by the existing LoadTimeWeaverimplementations, a JDK agent can be the only solution. For such cases, Spring provides InstrumentationLoadTimeWeaver, which requires a Spring-specific (but very general) VM agent, org.springframework.instrument-{version}.jar(previously named spring-agent.jar).

To use it, you must start the virtual machine with the Spring agent, by supplying the following JVM options:

-javaagent:/path/to/org.springframework.instrument-{version}.jar

Note that this requires modification of the VM launch script which may prevent you from using this in application server environments (depending on your operation policies). Additionally, the JDK agent will instrument the entireVM which can prove expensive.

For performance reasons, it is recommended to use this configuration only if your target environment (such as Jetty) does not have (or does not support) a dedicated LTW.

11.9 Further Resources

More information on AspectJ can be found on the AspectJ website.

The book Eclipse AspectJby Adrian Colyer et. al. (Addison-Wesley, 2005) provides a comprehensive introduction and reference for the AspectJ language.

The book AspectJ in Action, Second Editionby Ramnivas Laddad (Manning, 2009) comes highly recommended; the focus of the book is on AspectJ, but a lot of general AOP themes are explored (in some depth).

12. Spring AOP APIs

12.1 Introduction

The previous chapter described the Spring’s support for AOP using @AspectJ and schema-based aspect definitions. In this chapter we discuss the lower-level Spring AOP APIs and the AOP support used in Spring 1.2 applications. For new applications, we recommend the use of the Spring 2.0 and later AOP support described in the previous chapter, but when working with existing applications, or when reading books and articles, you may come across Spring 1.2 style examples. Spring 4.0 is backwards compatible with Spring 1.2 and everything described in this chapter is fully supported in Spring 4.0.

12.2 Pointcut API in Spring

Let’s look at how Spring handles the crucial pointcut concept.

12.2.1 Concepts

Spring’s pointcut model enables pointcut reuse independent of advice types. It’s possible to target different advice using the same pointcut.

The org.springframework.aop.Pointcutinterface is the central interface, used to target advices to particular classes and methods. The complete interface is shown below:

								public
								interfacePointcut { ClassFilter getClassFilter(); MethodMatcher getMethodMatcher(); }

Splitting the Pointcutinterface into two parts allows reuse of class and method matching parts, and fine-grained composition operations (such as performing a "union" with another method matcher).

The ClassFilterinterface is used to restrict the pointcut to a given set of target classes. If the matches()method always returns true, all target classes will be matched:

								public
								interfaceClassFilter {
								booleanmatches(Class clazz); }

The MethodMatcherinterface is normally more important. The complete interface is shown below:

								public
								interfaceMethodMatcher {
								booleanmatches(Method m, Class targetClass);
								booleanisRuntime();
								booleanmatches(Method m, Class targetClass, Object[] args); }

The matches(Method, Class)method is used to test whether this pointcut will ever match a given method on a target class. This evaluation can be performed when an AOP proxy is created, to avoid the need for a test on every method invocation. If the 2-argument matches method returns true for a given method, and the isRuntime()method for the MethodMatcher returns true, the 3-argument matches method will be invoked on every method invocation. This enables a pointcut to look at the arguments passed to the method invocation immediately before the target advice is to execute.

Most MethodMatchers are static, meaning that their isRuntime()method returns false. In this case, the 3-argument matches method will never be invoked.

[Tip] Tip

If possible, try to make pointcuts static, allowing the AOP framework to cache the results of pointcut evaluation when an AOP proxy is created.

12.2.2 Operations on pointcuts

Spring supports operations on pointcuts: notably, unionand intersection.

  • Union means the methods that either pointcut matches.
  • Intersection means the methods that both pointcuts match.
  • Union is usually more useful.
  • Pointcuts can be composed using the static methods in the org.springframework.aop.support.Pointcutsclass, or using the ComposablePointcutclass in the same package. However, using AspectJ pointcut expressions is usually a simpler approach.

12.2.3 AspectJ expression pointcuts

Since 2.0, the most important type of pointcut used by Spring is org.springframework.aop.aspectj.AspectJExpressionPointcut. This is a pointcut that uses an AspectJ supplied library to parse an AspectJ pointcut expression string.

See the previous chapter for a discussion of supported AspectJ pointcut primitives.

12.2.4 Convenience pointcut implementations

Spring provides several convenient pointcut implementations. Some can be used out of the box; others are intended to be subclassed in application-specific pointcuts.

Static pointcuts

Static pointcuts are based on method and target class, and cannot take into account the method’s arguments. Static pointcuts are sufficient - and best- for most usages. It’s possible for Spring to evaluate a static pointcut only once, when a method is first invoked: after that, there is no need to evaluate the pointcut again with each method invocation.

Let’s consider some static pointcut implementations included with Spring.

Regular expression pointcuts

One obvious way to specify static pointcuts is regular expressions. Several AOP frameworks besides Spring make this possible. org.springframework.aop.support.JdkRegexpMethodPointcutis a generic regular expression pointcut, using the regular expression support in JDK 1.4+.

Using the JdkRegexpMethodPointcutclass, you can provide a list of pattern Strings. If any of these is a match, the pointcut will evaluate to true. (So the result is effectively the union of these pointcuts.)

The usage is shown below:

										<bean
										id=
										"settersAndAbsquatulatePointcut"
										class=
										"org.springframework.aop.support.JdkRegexpMethodPointcut"
										>
										<property
										name=
										"patterns"
										>
										<list>
										<value>.*set.*
										</value>
										<value>.*absquatulate
										</value>
										</list>
										</property>
										</bean>

Spring provides a convenience class, RegexpMethodPointcutAdvisor, that allows us to also reference an Advice (remember that an Advice can be an interceptor, before advice, throws advice etc.). Behind the scenes, Spring will use a JdkRegexpMethodPointcut. Using RegexpMethodPointcutAdvisorsimplifies wiring, as the one bean encapsulates both pointcut and advice, as shown below:

										<bean
										id=
										"settersAndAbsquatulateAdvisor"
										class=
										"org.springframework.aop.support.RegexpMethodPointcutAdvisor"
										>
										<property
										name=
										"advice"
										>
										<ref
										bean=
										"beanNameOfAopAllianceInterceptor"
										/>
										</property>
										<property
										name=
										"patterns"
										>
										<list>
										<value>.*set.*
										</value>
										<value>.*absquatulate
										</value>
										</list>
										</property>
										</bean>

RegexpMethodPointcutAdvisorcan be used with any Advice type.

Attribute-driven pointcuts

An important type of static pointcut is a metadata-drivenpointcut. This uses the values of metadata attributes: typically, source-level metadata.

Dynamic pointcuts

Dynamic pointcuts are costlier to evaluate than static pointcuts. They take into account method arguments, as well as static information. This means that they must be evaluated with every method invocation; the result cannot be cached, as arguments will vary.

The main example is the control flowpointcut.

Control flow pointcuts

Spring control flow pointcuts are conceptually similar to AspectJ cflowpointcuts, although less powerful. (There is currently no way to specify that a pointcut executes below a join point matched by another pointcut.) A control flow pointcut matches the current call stack. For example, it might fire if the join point was invoked by a method in the com.mycompany.webpackage, or by the SomeCallerclass. Control flow pointcuts are specified using the org.springframework.aop.support.ControlFlowPointcutclass.

[Note] Note

Control flow pointcuts are significantly more expensive to evaluate at runtime than even other dynamic pointcuts. In Java 1.4, the cost is about 5 times that of other dynamic pointcuts.

12.2.5 Pointcut superclasses

Spring provides useful pointcut superclasses to help you to implement your own pointcuts.

Because static pointcuts are most useful, you’ll probably subclass StaticMethodMatcherPointcut, as shown below. This requires implementing just one abstract method (although it’s possible to override other methods to customize behavior):

								classTestStaticPointcut
								extendsStaticMethodMatcherPointcut {
								public
								booleanmatches(Method m, Class targetClass) {
								// return true if custom criteria match} }

There are also superclasses for dynamic pointcuts.

You can use custom pointcuts with any advice type in Spring 1.0 RC2 and above.

12.2.6 Custom pointcuts

Because pointcuts in Spring AOP are Java classes, rather than language features (as in AspectJ) it’s possible to declare custom pointcuts, whether static or dynamic. Custom pointcuts in Spring can be arbitrarily complex. However, using the AspectJ pointcut expression language is recommended if possible.

[Note] Note

Later versions of Spring may offer support for "semantic pointcuts" as offered by JAC: for example, "all methods that change instance variables in the target object."

12.3 Advice API in Spring

Let’s now look at how Spring AOP handles advice.

12.3.1 Advice lifecycles

Each advice is a Spring bean. An advice instance can be shared across all advised objects, or unique to each advised object. This corresponds to per-classor per-instanceadvice.

Per-class advice is used most often. It is appropriate for generic advice such as transaction advisors. These do not depend on the state of the proxied object or add new state; they merely act on the method and arguments.

Per-instance advice is appropriate for introductions, to support mixins. In this case, the advice adds state to the proxied object.

It’s possible to use a mix of shared and per-instance advice in the same AOP proxy.

12.3.2 Advice types in Spring

Spring provides several advice types out of the box, and is extensible to support arbitrary advice types. Let us look at the basic concepts and standard advice types.

Interception around advice

The most fundamental advice type in Spring is interception around advice.

Spring is compliant with the AOP Alliance interface for around advice using method interception. MethodInterceptors implementing around advice should implement the following interface:

									public
									interfaceMethodInterceptor
									extendsInterceptor { Object invoke(MethodInvocation invocation)
									throwsThrowable; }

The MethodInvocationargument to the invoke()method exposes the method being invoked; the target join point; the AOP proxy; and the arguments to the method. The invoke()method should return the invocation’s result: the return value of the join point.

A simple MethodInterceptorimplementation looks as follows:

									public
									classDebugInterceptor
									implementsMethodInterceptor {
									publicObject invoke(MethodInvocation invocation)
									throwsThrowable { System.out.println(
									"Before: invocation=["+ invocation +
									"]"); Object rval = invocation.proceed(); System.out.println(
									"Invocation returned");
									returnrval; } }

Note the call to the MethodInvocation’s proceed()method. This proceeds down the interceptor chain towards the join point. Most interceptors will invoke this method, and return its return value. However, a MethodInterceptor, like any around advice, can return a different value or throw an exception rather than invoke the proceed method. However, you don’t want to do this without good reason!

[Note] Note

MethodInterceptors offer interoperability with other AOP Alliance-compliant AOP implementations. The other advice types discussed in the remainder of this section implement common AOP concepts, but in a Spring-specific way. While there is an advantage in using the most specific advice type, stick with MethodInterceptor around advice if you are likely to want to run the aspect in another AOP framework. Note that pointcuts are not currently interoperable between frameworks, and the AOP Alliance does not currently define pointcut interfaces.

Before advice

A simpler advice type is a before advice. This does not need a MethodInvocationobject, since it will only be called before entering the method.

The main advantage of a before advice is that there is no need to invoke the proceed()method, and therefore no possibility of inadvertently failing to proceed down the interceptor chain.

The MethodBeforeAdviceinterface is shown below. (Spring’s API design would allow for field before advice, although the usual objects apply to field interception and it’s unlikely that Spring will ever implement it).

									public
									interfaceMethodBeforeAdvice
									extendsBeforeAdvice {
									voidbefore(Method m, Object[] args, Object target)
									throwsThrowable; }

Note the return type is void. Before advice can insert custom behavior before the join point executes, but cannot change the return value. If a before advice throws an exception, this will abort further execution of the interceptor chain. The exception will propagate back up the interceptor chain. If it is unchecked, or on the signature of the invoked method, it will be passed directly to the client; otherwise it will be wrapped in an unchecked exception by the AOP proxy.

An example of a before advice in Spring, which counts all method invocations:

									public
									classCountingBeforeAdvice
									implementsMethodBeforeAdvice {
									private
									intcount;
									public
									voidbefore(Method m, Object[] args, Object target)
									throwsThrowable { ++count; }
									public
									intgetCount() {
									returncount; } }
[Tip] Tip

Before advice can be used with any pointcut.

Throws advice

Throws adviceis invoked after the return of the join point if the join point threw an exception. Spring offers typed throws advice. Note that this means that the org.springframework.aop.ThrowsAdviceinterface does not contain any methods: It is a tag interface identifying that the given object implements one or more typed throws advice methods. These should be in the form of:

afterThrowing([Method, args, target], subclassOfThrowable)

Only the last argument is required. The method signatures may have either one or four arguments, depending on whether the advice method is interested in the method and arguments. The following classes are examples of throws advice.

The advice below is invoked if a RemoteExceptionis thrown (including subclasses):

									public
									classRemoteThrowsAdvice
									implementsThrowsAdvice {
									public
									voidafterThrowing(RemoteException ex)
									throwsThrowable {
									// Do something with remote exception} }

The following advice is invoked if a ServletExceptionis thrown. Unlike the above advice, it declares 4 arguments, so that it has access to the invoked method, method arguments and target object:

									public
									classServletThrowsAdviceWithArguments
									implementsThrowsAdvice {
									public
									voidafterThrowing(Method m, Object[] args, Object target, ServletException ex) {
									// Do something with all arguments} }

The final example illustrates how these two methods could be used in a single class, which handles both RemoteExceptionand ServletException. Any number of throws advice methods can be combined in a single class.

									public
									static
									classCombinedThrowsAdvice
									implementsThrowsAdvice {
									public
									voidafterThrowing(RemoteException ex)
									throwsThrowable {
									// Do something with remote exception}
									public
									voidafterThrowing(Method m, Object[] args, Object target, ServletException ex) {
									// Do something with all arguments} }
[Note] Note

If a throws-advice method throws an exception itself, it will override the original exception (i.e. change the exception thrown to the user). The overriding exception will typically be a RuntimeException; this is compatible with any method signature. However, if a throws-advice method throws a checked exception, it will have to match the declared exceptions of the target method and is hence to some degree coupled to specific target method signatures. Do not throw an undeclared checked exception that is incompatible with the target method’s signature!

[Tip] Tip

Throws advice can be used with any pointcut.

After Returning advice

An after returning advice in Spring must implement the org.springframework.aop.AfterReturningAdviceinterface, shown below:

									public
									interfaceAfterReturningAdvice
									extendsAdvice {
									voidafterReturning(Object returnValue, Method m, Object[] args, Object target)
									throwsThrowable; }

An after returning advice has access to the return value (which it cannot modify), invoked method, methods arguments and target.

The following after returning advice counts all successful method invocations that have not thrown exceptions:

									public
									classCountingAfterReturningAdvice
									implementsAfterReturningAdvice {
									private
									intcount;
									public
									voidafterReturning(Object returnValue, Method m, Object[] args, Object target)
									throwsThrowable { ++count; }
									public
									intgetCount() {
									returncount; } }

This advice doesn’t change the execution path. If it throws an exception, this will be thrown up the interceptor chain instead of the return value.

[Tip] Tip

After returning advice can be used with any pointcut.

Introduction advice

Spring treats introduction advice as a special kind of interception advice.

Introduction requires an IntroductionAdvisor, and an IntroductionInterceptor, implementing the following interface:

									public
									interfaceIntroductionInterceptor
									extendsMethodInterceptor {
									booleanimplementsInterface(Class intf); }

The invoke()method inherited from the AOP Alliance MethodInterceptorinterface must implement the introduction: that is, if the invoked method is on an introduced interface, the introduction interceptor is responsible for handling the method call - it cannot invoke proceed().

Introduction advice cannot be used with any pointcut, as it applies only at class, rather than method, level. You can only use introduction advice with the IntroductionAdvisor, which has the following methods:

									public
									interfaceIntroductionAdvisor
									extendsAdvisor, IntroductionInfo { ClassFilter getClassFilter();
									voidvalidateInterfaces()
									throwsIllegalArgumentException; }
									public
									interfaceIntroductionInfo { Class[] getInterfaces(); }

There is no MethodMatcher, and hence no Pointcut, associated with introduction advice. Only class filtering is logical.

The getInterfaces()method returns the interfaces introduced by this advisor.

The validateInterfaces()method is used internally to see whether or not the introduced interfaces can be implemented by the configured IntroductionInterceptor.

Let’s look at a simple example from the Spring test suite. Let’s suppose we want to introduce the following interface to one or more objects:

									public
									interfaceLockable {
									voidlock();
									voidunlock();
									booleanlocked(); }

This illustrates a mixin. We want to be able to cast advised objects to Lockable, whatever their type, and call lock and unlock methods. If we call the lock() method, we want all setter methods to throw a LockedException. Thus we can add an aspect that provides the ability to make objects immutable, without them having any knowledge of it: a good example of AOP.

Firstly, we’ll need an IntroductionInterceptorthat does the heavy lifting. In this case, we extend the org.springframework.aop.support.DelegatingIntroductionInterceptorconvenience class. We could implement IntroductionInterceptor directly, but using DelegatingIntroductionInterceptoris best for most cases.

The DelegatingIntroductionInterceptoris designed to delegate an introduction to an actual implementation of the introduced interface(s), concealing the use of interception to do so. The delegate can be set to any object using a constructor argument; the default delegate (when the no-arg constructor is used) is this. Thus in the example below, the delegate is the LockMixinsubclass of DelegatingIntroductionInterceptor. Given a delegate (by default itself), a DelegatingIntroductionInterceptorinstance looks for all interfaces implemented by the delegate (other than IntroductionInterceptor), and will support introductions against any of them. It’s possible for subclasses such as LockMixinto call the suppressInterface(Class intf)method to suppress interfaces that should not be exposed. However, no matter how many interfaces an IntroductionInterceptoris prepared to support, the IntroductionAdvisorused will control which interfaces are actually exposed. An introduced interface will conceal any implementation of the same interface by the target.

Thus LockMixinextends DelegatingIntroductionInterceptorand implements Lockableitself. The superclass automatically picks up that Lockable can be supported for introduction, so we don’t need to specify that. We could introduce any number of interfaces in this way.

Note the use of the lockedinstance variable. This effectively adds additional state to that held in the target object.

									public
									classLockMixin
									extendsDelegatingIntroductionInterceptor
									implementsLockable {
									private
									booleanlocked;
									public
									voidlock() {
									this.locked = true; }
									public
									voidunlock() {
									this.locked = false; }
									public
									booleanlocked() {
									return
									this.locked; }
									publicObject invoke(MethodInvocation invocation)
									throwsThrowable {
									if(locked() && invocation.getMethod().getName().indexOf(
									"set") ==
									0) {
									throw
									newLockedException(); }
									return
									super.invoke(invocation); } }

Often it isn’t necessary to override the invoke()method: the DelegatingIntroductionInterceptorimplementation - which calls the delegate method if the method is introduced, otherwise proceeds towards the join point - is usually sufficient. In the present case, we need to add a check: no setter method can be invoked if in locked mode.

The introduction advisor required is simple. All it needs to do is hold a distinct LockMixininstance, and specify the introduced interfaces - in this case, just Lockable. A more complex example might take a reference to the introduction interceptor (which would be defined as a prototype): in this case, there’s no configuration relevant for a LockMixin, so we simply create it using new.

									public
									classLockMixinAdvisor
									extendsDefaultIntroductionAdvisor {
									publicLockMixinAdvisor() {
									super(
									newLockMixin(), Lockable.
									class); } }

We can apply this advisor very simply: it requires no configuration. (However, it isnecessary: It’s impossible to use an IntroductionInterceptorwithout an IntroductionAdvisor.) As usual with introductions, the advisor must be per-instance, as it is stateful. We need a different instance of LockMixinAdvisor, and hence LockMixin, for each advised object. The advisor comprises part of the advised object’s state.

We can apply this advisor programmatically, using the Advised.addAdvisor()method, or (the recommended way) in XML configuration, like any other advisor. All proxy creation choices discussed below, including "auto proxy creators," correctly handle introductions and stateful mixins.

12.4 Advisor API in Spring

In Spring, an Advisor is an aspect that contains just a single advice object associated with a pointcut expression.

Apart from the special case of introductions, any advisor can be used with any advice. org.springframework.aop.support.DefaultPointcutAdvisoris the most commonly used advisor class. For example, it can be used with a MethodInterceptor, BeforeAdviceor ThrowsAdvice.

It is possible to mix advisor and advice types in Spring in the same AOP proxy. For example, you could use a interception around advice, throws advice and before advice in one proxy configuration: Spring will automatically create the necessary interceptor chain.

12.5 Using the ProxyFactoryBean to create AOP proxies

If you’re using the Spring IoC container (an ApplicationContext or BeanFactory) for your business objects - and you should be! - you will want to use one of Spring’s AOP FactoryBeans. (Remember that a factory bean introduces a layer of indirection, enabling it to create objects of a different type.)

[Note] Note

The Spring AOP support also uses factory beans under the covers.

The basic way to create an AOP proxy in Spring is to use the org.springframework.aop.framework.ProxyFactoryBean. This gives complete control over the pointcuts and advice that will apply, and their ordering. However, there are simpler options that are preferable if you don’t need such control.

12.5.1 Basics

The ProxyFactoryBean, like other Spring FactoryBeanimplementations, introduces a level of indirection. If you define a ProxyFactoryBeanwith name foo, what objects referencing foosee is not the ProxyFactoryBeaninstance itself, but an object created by the ProxyFactoryBean’s implementation of the `getObject()method. This method will create an AOP proxy wrapping a target object.

One of the most important benefits of using a ProxyFactoryBeanor another IoC-aware class to create AOP proxies, is that it means that advices and pointcuts can also be managed by IoC. This is a powerful feature, enabling certain approaches that are hard to achieve with other AOP frameworks. For example, an advice may itself reference application objects (besides the target, which should be available in any AOP framework), benefiting from all the pluggability provided by Dependency Injection.

12.5.2 JavaBean properties

In common with most FactoryBeanimplementations provided with Spring, the ProxyFactoryBeanclass is itself a JavaBean. Its properties are used to:

Some key properties are inherited from org.springframework.aop.framework.ProxyConfig(the superclass for all AOP proxy factories in Spring). These key properties include:

  • proxyTargetClass: trueif the target class is to be proxied, rather than the target class' interfaces. If this property value is set to true, then CGLIB proxies will be created (but see also Section 12.5.3, “JDK- and CGLIB-based proxies”).
  • optimize: controls whether or not aggressive optimizations are applied to proxies created via CGLIB. One should not blithely use this setting unless one fully understands how the relevant AOP proxy handles optimization. This is currently used only for CGLIB proxies; it has no effect with JDK dynamic proxies.
  • frozen: if a proxy configuration is frozen, then changes to the configuration are no longer allowed. This is useful both as a slight optimization and for those cases when you don’t want callers to be able to manipulate the proxy (via the Advisedinterface) after the proxy has been created. The default value of this property is false, so changes such as adding additional advice are allowed.
  • exposeProxy: determines whether or not the current proxy should be exposed in a ThreadLocalso that it can be accessed by the target. If a target needs to obtain the proxy and the exposeProxyproperty is set to true, the target can use the AopContext.currentProxy()method.

Other properties specific to ProxyFactoryBeaninclude:

  • proxyInterfaces: array of String interface names. If this isn’t supplied, a CGLIB proxy for the target class will be used (but see also Section 12.5.3, “JDK- and CGLIB-based proxies”).
  • interceptorNames: String array of Advisor, interceptor or other advice names to apply. Ordering is significant, on a first come-first served basis. That is to say that the first interceptor in the list will be the first to be able to intercept the invocation.

The names are bean names in the current factory, including bean names from ancestor factories. You can’t mention bean references here since doing so would result in the ProxyFactoryBeanignoring the singleton setting of the advice.

You can append an interceptor name with an asterisk ( *). This will result in the application of all advisor beans with names starting with the part before the asterisk to be applied. An example of using this feature can be found in Section 12.5.6, “Using 'global' advisors”.

  • singleton: whether or not the factory should return a single object, no matter how often the getObject()method is called. Several FactoryBeanimplementations offer such a method. The default value is true. If you want to use stateful advice - for example, for stateful mixins - use prototype advices along with a singleton value of false.

12.5.3 JDK- and CGLIB-based proxies

This section serves as the definitive documentation on how the ProxyFactoryBeanchooses to create one of either a JDK- and CGLIB-based proxy for a particular target object (that is to be proxied).

[Note] Note

The behavior of the ProxyFactoryBeanwith regard to creating JDK- or CGLIB-based proxies changed between versions 1.2.x and 2.0 of Spring. The ProxyFactoryBeannow exhibits similar semantics with regard to auto-detecting interfaces as those of the TransactionProxyFactoryBeanclass.

If the class of a target object that is to be proxied (hereafter simply referred to as the target class) doesn’t implement any interfaces, then a CGLIB-based proxy will be created. This is the easiest scenario, because JDK proxies are interface based, and no interfaces means JDK proxying isn’t even possible. One simply plugs in the target bean, and specifies the list of interceptors via the interceptorNamesproperty. Note that a CGLIB-based proxy will be created even if the proxyTargetClassproperty of the ProxyFactoryBeanhas been set to false. (Obviously this makes no sense, and is best removed from the bean definition because it is at best redundant, and at worst confusing.)

If the target class implements one (or more) interfaces, then the type of proxy that is created depends on the configuration of the ProxyFactoryBean.

If the proxyTargetClassproperty of the ProxyFactoryBeanhas been set to true, then a CGLIB-based proxy will be created. This makes sense, and is in keeping with the principle of least surprise. Even if the proxyInterfacesproperty of the ProxyFactoryBeanhas been set to one or more fully qualified interface names, the fact that the proxyTargetClassproperty is set to true willcause CGLIB-based proxying to be in effect.

If the proxyInterfacesproperty of the ProxyFactoryBeanhas been set to one or more fully qualified interface names, then a JDK-based proxy will be created. The created proxy will implement all of the interfaces that were specified in the proxyInterfacesproperty; if the target class happens to implement a whole lot more interfaces than those specified in the proxyInterfacesproperty, that is all well and good but those additional interfaces will not be implemented by the returned proxy.

If the proxyInterfacesproperty of the ProxyFactoryBeanhas notbeen set, but the target class does implement one (or more)interfaces, then the ProxyFactoryBeanwill auto-detect the fact that the target class does actually implement at least one interface, and a JDK-based proxy will be created. The interfaces that are actually proxied will be allof the interfaces that the target class implements; in effect, this is the same as simply supplying a list of each and every interface that the target class implements to the proxyInterfacesproperty. However, it is significantly less work, and less prone to typos.

12.5.4 Proxying interfaces

Let’s look at a simple example of ProxyFactoryBeanin action. This example involves:

  • A target beanthat will be proxied. This is the "personTarget" bean definition in the example below.
  • An Advisor and an Interceptor used to provide advice.
  • An AOP proxy bean definition specifying the target object (the personTarget bean) and the interfaces to proxy, along with the advices to apply.
								<bean
								id=
								"personTarget"
								class=
								"com.mycompany.PersonImpl"
								>
								<property
								name=
								"name"
								value=
								"Tony"
								/>
								<property
								name=
								"age"
								value=
								"51"
								/>
								</bean>
								<bean
								id=
								"myAdvisor"
								class=
								"com.mycompany.MyAdvisor"
								>
								<property
								name=
								"someProperty"
								value=
								"Custom string property value"
								/>
								</bean>
								<bean
								id=
								"debugInterceptor"
								class=
								"org.springframework.aop.interceptor.DebugInterceptor"
								>
								</bean>
								<bean
								id=
								"person"
								class=
								"org.springframework.aop.framework.ProxyFactoryBean"
								>
								<property
								name=
								"proxyInterfaces"
								value=
								"com.mycompany.Person"
								/>
								<property
								name=
								"target"
								ref=
								"personTarget"
								/>
								<property
								name=
								"interceptorNames"
								>
								<list>
								<value>myAdvisor
								</value>
								<value>debugInterceptor
								</value>
								</list>
								</property>
								</bean>

Note that the interceptorNamesproperty takes a list of String: the bean names of the interceptor or advisors in the current factory. Advisors, interceptors, before, after returning and throws advice objects can be used. The ordering of advisors is significant.

[Note] Note

You might be wondering why the list doesn’t hold bean references. The reason for this is that if the ProxyFactoryBean’s singleton property is set to false, it must be able to return independent proxy instances. If any of the advisors is itself a prototype, an independent instance would need to be returned, so it’s necessary to be able to obtain an instance of the prototype from the factory; holding a reference isn’t sufficient.

The "person" bean definition above can be used in place of a Person implementation, as follows:

Person person = (Person) factory.getBean(
								"person");

Other beans in the same IoC context can express a strongly typed dependency on it, as with an ordinary Java object:

								<bean
								id=
								"personUser"
								class=
								"com.mycompany.PersonUser"
								>
								<property
								name=
								"person"
								>
								<ref
								bean=
								"person"
								/>
								</property>
								</bean>

The PersonUserclass in this example would expose a property of type Person. As far as it’s concerned, the AOP proxy can be used transparently in place of a "real" person implementation. However, its class would be a dynamic proxy class. It would be possible to cast it to the Advisedinterface (discussed below).

It’s possible to conceal the distinction between target and proxy using an anonymous inner bean, as follows. Only the ProxyFactoryBeandefinition is different; the advice is included only for completeness:

								<bean
								id=
								"myAdvisor"
								class=
								"com.mycompany.MyAdvisor"
								>
								<property
								name=
								"someProperty"
								value=
								"Custom string property value"
								/>
								</bean>
								<bean
								id=
								"debugInterceptor"
								class=
								"org.springframework.aop.interceptor.DebugInterceptor"
								/>
								<bean
								id=
								"person"
								class=
								"org.springframework.aop.framework.ProxyFactoryBean"
								>
								<property
								name=
								"proxyInterfaces"
								value=
								"com.mycompany.Person"
								/>
								<!-- Use inner bean, not local reference to target -->
								<property
								name=
								"target"
								>
								<bean
								class=
								"com.mycompany.PersonImpl"
								>
								<property
								name=
								"name"
								value=
								"Tony"
								/>
								<property
								name=
								"age"
								value=
								"51"
								/>
								</bean>
								</property>
								<property
								name=
								"interceptorNames"
								>
								<list>
								<value>myAdvisor
								</value>
								<value>debugInterceptor
								</value>
								</list>
								</property>
								</bean>

This has the advantage that there’s only one object of type Person: useful if we want to prevent users of the application context from obtaining a reference to the un-advised object, or need to avoid any ambiguity with Spring IoC autowiring. There’s also arguably an advantage in that the ProxyFactoryBean definition is self-contained. However, there are times when being able to obtain the un-advised target from the factory might actually be an advantage: for example, in certain test scenarios.

12.5.5 Proxying classes

What if you need to proxy a class, rather than one or more interfaces?

Imagine that in our example above, there was no Personinterface: we needed to advise a class called Personthat didn’t implement any business interface. In this case, you can configure Spring to use CGLIB proxying, rather than dynamic proxies. Simply set the proxyTargetClassproperty on the ProxyFactoryBean above to true. While it’s best to program to interfaces, rather than classes, the ability to advise classes that don’t implement interfaces can be useful when working with legacy code. (In general, Spring isn’t prescriptive. While it makes it easy to apply good practices, it avoids forcing a particular approach.)

If you want to, you can force the use of CGLIB in any case, even if you do have interfaces.

CGLIB proxying works by generating a subclass of the target class at runtime. Spring configures this generated subclass to delegate method calls to the original target: the subclass is used to implement the Decoratorpattern, weaving in the advice.

CGLIB proxying should generally be transparent to users. However, there are some issues to consider:

  • Finalmethods can’t be advised, as they can’t be overridden.
  • There is no need to add CGLIB to your classpath. As of Spring 3.2, CGLIB is repackaged and included in the spring-core JAR. In other words, CGLIB-based AOP will work "out of the box" just as do JDK dynamic proxies.

There’s little performance difference between CGLIB proxying and dynamic proxies. As of Spring 1.0, dynamic proxies are slightly faster. However, this may change in the future. Performance should not be a decisive consideration in this case.

12.5.6 Using 'global' advisors

By appending an asterisk to an interceptor name, all advisors with bean names matching the part before the asterisk, will be added to the advisor chain. This can come in handy if you need to add a standard set of 'global' advisors:

								<bean
								id=
								"proxy"
								class=
								"org.springframework.aop.framework.ProxyFactoryBean"
								>
								<property
								name=
								"target"
								ref=
								"service"
								/>
								<property
								name=
								"interceptorNames"
								>
								<list>
								<value>global*
								</value>
								</list>
								</property>
								</bean>
								<bean
								id=
								"global_debug"
								class=
								"org.springframework.aop.interceptor.DebugInterceptor"
								/>
								<bean
								id=
								"global_performance"
								class=
								"org.springframework.aop.interceptor.PerformanceMonitorInterceptor"
								/>

12.6 Concise proxy definitions

Especially when defining transactional proxies, you may end up with many similar proxy definitions. The use of parent and child bean definitions, along with inner bean definitions, can result in much cleaner and more concise proxy definitions.

First a parent, template, bean definition is created for the proxy:

							<bean
							id=
							"txProxyTemplate"
							abstract=
							"true"
							class=
							"org.springframework.transaction.interceptor.TransactionProxyFactoryBean"
							>
							<property
							name=
							"transactionManager"
							ref=
							"transactionManager"
							/>
							<property
							name=
							"transactionAttributes"
							>
							<props>
							<prop
							key=
							"*"
							>PROPAGATION_REQUIRED
							</prop>
							</props>
							</property>
							</bean>

This will never be instantiated itself, so may actually be incomplete. Then each proxy which needs to be created is just a child bean definition, which wraps the target of the proxy as an inner bean definition, since the target will never be used on its own anyway.

							<bean
							id=
							"myService"
							parent=
							"txProxyTemplate"
							>
							<property
							name=
							"target"
							>
							<bean
							class=
							"org.springframework.samples.MyServiceImpl"
							>
							</bean>
							</property>
							</bean>

It is of course possible to override properties from the parent template, such as in this case, the transaction propagation settings:

							<bean
							id=
							"mySpecialService"
							parent=
							"txProxyTemplate"
							>
							<property
							name=
							"target"
							>
							<bean
							class=
							"org.springframework.samples.MySpecialServiceImpl"
							>
							</bean>
							</property>
							<property
							name=
							"transactionAttributes"
							>
							<props>
							<prop
							key=
							"get*"
							>PROPAGATION_REQUIRED,readOnly
							</prop>
							<prop
							key=
							"find*"
							>PROPAGATION_REQUIRED,readOnly
							</prop>
							<prop
							key=
							"load*"
							>PROPAGATION_REQUIRED,readOnly
							</prop>
							<prop
							key=
							"store*"
							>PROPAGATION_REQUIRED
							</prop>
							</props>
							</property>
							</bean>

Note that in the example above, we have explicitly marked the parent bean definition as abstractby using the abstractattribute, as described previously, so that it may not actually ever be instantiated. Application contexts (but not simple bean factories) will by default pre-instantiate all singletons. It is therefore important (at least for singleton beans) that if you have a (parent) bean definition which you intend to use only as a template, and this definition specifies a class, you must make sure to set the abstractattribute to true, otherwise the application context will actually try to pre-instantiate it.

12.7 Creating AOP proxies programmatically with the ProxyFactory

It’s easy to create AOP proxies programmatically using Spring. This enables you to use Spring AOP without dependency on Spring IoC.

The following listing shows creation of a proxy for a target object, with one interceptor and one advisor. The interfaces implemented by the target object will automatically be proxied:

ProxyFactory factory =
							newProxyFactory(myBusinessInterfaceImpl); factory.addAdvice(myMethodInterceptor); factory.addAdvisor(myAdvisor); MyBusinessInterface tb = (MyBusinessInterface) factory.getProxy();

The first step is to construct an object of type org.springframework.aop.framework.ProxyFactory. You can create this with a target object, as in the above example, or specify the interfaces to be proxied in an alternate constructor.

You can add advices (with interceptors as a specialized kind of advice) and/or advisors, and manipulate them for the life of the ProxyFactory. If you add an IntroductionInterceptionAroundAdvisor, you can cause the proxy to implement additional interfaces.

There are also convenience methods on ProxyFactory (inherited from AdvisedSupport) which allow you to add other advice types such as before and throws advice. AdvisedSupport is the superclass of both ProxyFactory and ProxyFactoryBean.

[Tip] Tip

Integrating AOP proxy creation with the IoC framework is best practice in most applications. We recommend that you externalize configuration from Java code with AOP, as in general.

12.8 Manipulating advised objects

However you create AOP proxies, you can manipulate them using the org.springframework.aop.framework.Advisedinterface. Any AOP proxy can be cast to this interface, whichever other interfaces it implements. This interface includes the following methods:

Advisor[] getAdvisors();
							voidaddAdvice(Advice advice)
							throwsAopConfigException;
							voidaddAdvice(
							intpos, Advice advice)
							throwsAopConfigException;
							voidaddAdvisor(Advisor advisor)
							throwsAopConfigException;
							voidaddAdvisor(
							intpos, Advisor advisor)
							throwsAopConfigException;
							intindexOf(Advisor advisor);
							booleanremoveAdvisor(Advisor advisor)
							throwsAopConfigException;
							voidremoveAdvisor(
							intindex)
							throwsAopConfigException;
							booleanreplaceAdvisor(Advisor a, Advisor b)
							throwsAopConfigException;
							booleanisFrozen();

The getAdvisors()method will return an Advisor for every advisor, interceptor or other advice type that has been added to the factory. If you added an Advisor, the returned advisor at this index will be the object that you added. If you added an interceptor or other advice type, Spring will have wrapped this in an advisor with a pointcut that always returns true. Thus if you added a MethodInterceptor, the advisor returned for this index will be an DefaultPointcutAdvisorreturning your MethodInterceptorand a pointcut that matches all classes and methods.

The addAdvisor()methods can be used to add any Advisor. Usually the advisor holding pointcut and advice will be the generic DefaultPointcutAdvisor, which can be used with any advice or pointcut (but not for introductions).

By default, it’s possible to add or remove advisors or interceptors even once a proxy has been created. The only restriction is that it’s impossible to add or remove an introduction advisor, as existing proxies from the factory will not show the interface change. (You can obtain a new proxy from the factory to avoid this problem.)

A simple example of casting an AOP proxy to the Advisedinterface and examining and manipulating its advice:

Advised advised = (Advised) myObject; Advisor[] advisors = advised.getAdvisors();
							intoldAdvisorCount = advisors.length; System.out.println(oldAdvisorCount +
							" advisors");
							// Add an advice like an interceptor without a pointcut
							// Will match all proxied methods
							// Can use for interceptors, before, after returning or throws adviceadvised.addAdvice(
							newDebugInterceptor());
							// Add selective advice using a pointcutadvised.addAdvisor(
							newDefaultPointcutAdvisor(mySpecialPointcut, myAdvice)); assertEquals(
							"Added two advisors", oldAdvisorCount +
							2, advised.getAdvisors().length);
[Note] Note

It’s questionable whether it’s advisable (no pun intended) to modify advice on a business object in production, although there are no doubt legitimate usage cases. However, it can be very useful in development: for example, in tests. I have sometimes found it very useful to be able to add test code in the form of an interceptor or other advice, getting inside a method invocation I want to test. (For example, the advice can get inside a transaction created for that method: for example, to run SQL to check that a database was correctly updated, before marking the transaction for roll back.)

Depending on how you created the proxy, you can usually set a frozenflag, in which case the Advised isFrozen()method will return true, and any attempts to modify advice through addition or removal will result in an AopConfigException. The ability to freeze the state of an advised object is useful in some cases, for example, to prevent calling code removing a security interceptor. It may also be used in Spring 1.1 to allow aggressive optimization if runtime advice modification is known not to be required.

12.9 Using the "auto-proxy" facility

So far we’ve considered explicit creation of AOP proxies using a ProxyFactoryBeanor similar factory bean.

Spring also allows us to use "auto-proxy" bean definitions, which can automatically proxy selected bean definitions. This is built on Spring "bean post processor" infrastructure, which enables modification of any bean definition as the container loads.

In this model, you set up some special bean definitions in your XML bean definition file to configure the auto proxy infrastructure. This allows you just to declare the targets eligible for auto-proxying: you don’t need to use ProxyFactoryBean.

There are two ways to do this:

  • Using an auto-proxy creator that refers to specific beans in the current context.
  • A special case of auto-proxy creation that deserves to be considered separately; auto-proxy creation driven by source-level metadata attributes.

12.9.1 Autoproxy bean definitions

The org.springframework.aop.framework.autoproxypackage provides the following standard auto-proxy creators.

BeanNameAutoProxyCreator

The BeanNameAutoProxyCreatorclass is a BeanPostProcessorthat automatically creates AOP proxies for beans with names matching literal values or wildcards.

									<bean
									class=
									"org.springframework.aop.framework.autoproxy.BeanNameAutoProxyCreator"
									>
									<property
									name=
									"beanNames"
									value=
									"jdk*,onlyJdk"
									/>
									<property
									name=
									"interceptorNames"
									>
									<list>
									<value>myInterceptor
									</value>
									</list>
									</property>
									</bean>

As with ProxyFactoryBean, there is an interceptorNamesproperty rather than a list of interceptors, to allow correct behavior for prototype advisors. Named "interceptors" can be advisors or any advice type.

As with auto proxying in general, the main point of using BeanNameAutoProxyCreatoris to apply the same configuration consistently to multiple objects, with minimal volume of configuration. It is a popular choice for applying declarative transactions to multiple objects.

Bean definitions whose names match, such as "jdkMyBean" and "onlyJdk" in the above example, are plain old bean definitions with the target class. An AOP proxy will be created automatically by the BeanNameAutoProxyCreator. The same advice will be applied to all matching beans. Note that if advisors are used (rather than the interceptor in the above example), the pointcuts may apply differently to different beans.

DefaultAdvisorAutoProxyCreator

A more general and extremely powerful auto proxy creator is DefaultAdvisorAutoProxyCreator. This will automagically apply eligible advisors in the current context, without the need to include specific bean names in the auto-proxy advisor’s bean definition. It offers the same merit of consistent configuration and avoidance of duplication as BeanNameAutoProxyCreator.

Using this mechanism involves:

  • Specifying a DefaultAdvisorAutoProxyCreatorbean definition.
  • Specifying any number of Advisors in the same or related contexts. Note that these mustbe Advisors, not just interceptors or other advices. This is necessary because there must be a pointcut to evaluate, to check the eligibility of each advice to candidate bean definitions.

The DefaultAdvisorAutoProxyCreatorwill automatically evaluate the pointcut contained in each advisor, to see what (if any) advice it should apply to each business object (such as "businessObject1" and "businessObject2" in the example).

This means that any number of advisors can be applied automatically to each business object. If no pointcut in any of the advisors matches any method in a business object, the object will not be proxied. As bean definitions are added for new business objects, they will automatically be proxied if necessary.

Autoproxying in general has the advantage of making it impossible for callers or dependencies to obtain an un-advised object. Calling getBean("businessObject1") on this ApplicationContext will return an AOP proxy, not the target business object. (The "inner bean" idiom shown earlier also offers this benefit.)

									<bean
									class=
									"org.springframework.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator"
									/>
									<bean
									class=
									"org.springframework.transaction.interceptor.TransactionAttributeSourceAdvisor"
									>
									<property
									name=
									"transactionInterceptor"
									ref=
									"transactionInterceptor"
									/>
									</bean>
									<bean
									id=
									"customAdvisor"
									class=
									"com.mycompany.MyAdvisor"
									/>
									<bean
									id=
									"businessObject1"
									class=
									"com.mycompany.BusinessObject1"
									>
									<!-- Properties omitted -->
									</bean>
									<bean
									id=
									"businessObject2"
									class=
									"com.mycompany.BusinessObject2"
									/>

The DefaultAdvisorAutoProxyCreatoris very useful if you want to apply the same advice consistently to many business objects. Once the infrastructure definitions are in place, you can simply add new business objects without including specific proxy configuration. You can also drop in additional aspects very easily - for example, tracing or performance monitoring aspects - with minimal change to configuration.

The DefaultAdvisorAutoProxyCreator offers support for filtering (using a naming convention so that only certain advisors are evaluated, allowing use of multiple, differently configured, AdvisorAutoProxyCreators in the same factory) and ordering. Advisors can implement the org.springframework.core.Orderedinterface to ensure correct ordering if this is an issue. The TransactionAttributeSourceAdvisor used in the above example has a configurable order value; the default setting is unordered.

AbstractAdvisorAutoProxyCreator

This is the superclass of DefaultAdvisorAutoProxyCreator. You can create your own auto-proxy creators by subclassing this class, in the unlikely event that advisor definitions offer insufficient customization to the behavior of the framework DefaultAdvisorAutoProxyCreator.

12.9.2 Using metadata-driven auto-proxying

A particularly important type of auto-proxying is driven by metadata. This produces a similar programming model to .NET ServicedComponents. Instead of defining metadata in XML descriptors, configuration for transaction management and other enterprise services is held in source-level attributes.

In this case, you use the DefaultAdvisorAutoProxyCreator, in combination with Advisors that understand metadata attributes. The metadata specifics are held in the pointcut part of the candidate advisors, rather than in the auto-proxy creation class itself.

This is really a special case of the DefaultAdvisorAutoProxyCreator, but deserves consideration on its own. (The metadata-aware code is in the pointcuts contained in the advisors, not the AOP framework itself.)

The /attributesdirectory of the JPetStore sample application shows the use of attribute-driven auto-proxying. In this case, there’s no need to use the TransactionProxyFactoryBean. Simply defining transactional attributes on business objects is sufficient, because of the use of metadata-aware pointcuts. The bean definitions include the following code, in /WEB-INF/declarativeServices.xml. Note that this is generic, and can be used outside the JPetStore:

								<bean
								class=
								"org.springframework.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator"
								/>
								<bean
								class=
								"org.springframework.transaction.interceptor.TransactionAttributeSourceAdvisor"
								>
								<property
								name=
								"transactionInterceptor"
								ref=
								"transactionInterceptor"
								/>
								</bean>
								<bean
								id=
								"transactionInterceptor"
								class=
								"org.springframework.transaction.interceptor.TransactionInterceptor"
								>
								<property
								name=
								"transactionManager"
								ref=
								"transactionManager"
								/>
								<property
								name=
								"transactionAttributeSource"
								>
								<bean
								class=
								"org.springframework.transaction.interceptor.AttributesTransactionAttributeSource"
								>
								<property
								name=
								"attributes"
								ref=
								"attributes"
								/>
								</bean>
								</property>
								</bean>
								<bean
								id=
								"attributes"
								class=
								"org.springframework.metadata.commons.CommonsAttributes"
								/>

The DefaultAdvisorAutoProxyCreatorbean definition (the name is not significant, hence it can even be omitted) will pick up all eligible pointcuts in the current application context. In this case, the "transactionAdvisor" bean definition, of type TransactionAttributeSourceAdvisor, will apply to classes or methods carrying a transaction attribute. The TransactionAttributeSourceAdvisor depends on a TransactionInterceptor, via constructor dependency. The example resolves this via autowiring. The AttributesTransactionAttributeSourcedepends on an implementation of the org.springframework.metadata.Attributesinterface. In this fragment, the "attributes" bean satisfies this, using the Jakarta Commons Attributes API to obtain attribute information. (The application code must have been compiled using the Commons Attributes compilation task.)

The /annotationdirectory of the JPetStore sample application contains an analogous example for auto-proxying driven by JDK 1.5+ annotations. The following configuration enables automatic detection of Spring’s Transactionalannotation, leading to implicit proxies for beans containing that annotation:

								<bean
								class=
								"org.springframework.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator"
								/>
								<bean
								class=
								"org.springframework.transaction.interceptor.TransactionAttributeSourceAdvisor"
								>
								<property
								name=
								"transactionInterceptor"
								ref=
								"transactionInterceptor"
								/>
								</bean>
								<bean
								id=
								"transactionInterceptor"
								class=
								"org.springframework.transaction.interceptor.TransactionInterceptor"
								>
								<property
								name=
								"transactionManager"
								ref=
								"transactionManager"
								/>
								<property
								name=
								"transactionAttributeSource"
								>
								<bean
								class=
								"org.springframework.transaction.annotation.AnnotationTransactionAttributeSource"
								/>
								</property>
								</bean>

The TransactionInterceptordefined here depends on a PlatformTransactionManagerdefinition, which is not included in this generic file (although it could be) because it will be specific to the application’s transaction requirements (typically JTA, as in this example, or Hibernate, JDO or JDBC):

								<bean
								id=
								"transactionManager"
								class=
								"org.springframework.transaction.jta.JtaTransactionManager"
								/>
[Tip] Tip

If you require only declarative transaction management, using these generic XML definitions will result in Spring automatically proxying all classes or methods with transaction attributes. You won’t need to work directly with AOP, and the programming model is similar to that of .NET ServicedComponents.

This mechanism is extensible. It’s possible to do auto-proxying based on custom attributes. You need to:

  • Define your custom attribute.
  • Specify an Advisor with the necessary advice, including a pointcut that is triggered by the presence of the custom attribute on a class or method. You may be able to use an existing advice, merely implementing a static pointcut that picks up the custom attribute.

It’s possible for such advisors to be unique to each advised class (for example, mixins): they simply need to be defined as prototype, rather than singleton, bean definitions. For example, the LockMixinintroduction interceptor from the Spring test suite, shown above, could be used in conjunction with a generic DefaultIntroductionAdvisor:

								<bean
								id=
								"lockMixin"
								class=
								"test.mixin.LockMixin"
								scope=
								"prototype"
								/>
								<bean
								id=
								"lockableAdvisor"
								class=
								"org.springframework.aop.support.DefaultIntroductionAdvisor"
								scope=
								"prototype"
								>
								<constructor-arg
								ref=
								"lockMixin"
								/>
								</bean>

Note that both lockMixinand lockableAdvisorare defined as prototypes.

12.10 Using TargetSources

Spring offers the concept of a TargetSource, expressed in the org.springframework.aop.TargetSourceinterface. This interface is responsible for returning the "target object" implementing the join point. The TargetSourceimplementation is asked for a target instance each time the AOP proxy handles a method invocation.

Developers using Spring AOP don’t normally need to work directly with TargetSources, but this provides a powerful means of supporting pooling, hot swappable and other sophisticated targets. For example, a pooling TargetSource can return a different target instance for each invocation, using a pool to manage instances.

If you do not specify a TargetSource, a default implementation is used that wraps a local object. The same target is returned for each invocation (as you would expect).

Let’s look at the standard target sources provided with Spring, and how you can use them.

[Tip] Tip

When using a custom target source, your target will usually need to be a prototype rather than a singleton bean definition. This allows Spring to create a new target instance when required.

12.10.1 Hot swappable target sources

The org.springframework.aop.target.HotSwappableTargetSourceexists to allow the target of an AOP proxy to be switched while allowing callers to keep their references to it.

Changing the target source’s target takes effect immediately. The HotSwappableTargetSourceis threadsafe.

You can change the target via the swap()method on HotSwappableTargetSource as follows:

HotSwappableTargetSource swapper = (HotSwappableTargetSource) beanFactory.getBean(
								"swapper"); Object oldTarget = swapper.swap(newTarget);

The XML definitions required look as follows:

								<bean
								id=
								"initialTarget"
								class=
								"mycompany.OldTarget"
								/>
								<bean
								id=
								"swapper"
								class=
								"org.springframework.aop.target.HotSwappableTargetSource"
								>
								<constructor-arg
								ref=
								"initialTarget"
								/>
								</bean>
								<bean
								id=
								"swappable"
								class=
								"org.springframework.aop.framework.ProxyFactoryBean"
								>
								<property
								name=
								"targetSource"
								ref=
								"swapper"
								/>
								</bean>

The above swap()call changes the target of the swappable bean. Clients who hold a reference to that bean will be unaware of the change, but will immediately start hitting the new target.

Although this example doesn’t add any advice - and it’s not necessary to add advice to use a TargetSource- of course any TargetSourcecan be used in conjunction with arbitrary advice.

12.10.2 Pooling target sources

Using a pooling target source provides a similar programming model to stateless session EJBs, in which a pool of identical instances is maintained, with method invocations going to free objects in the pool.

A crucial difference between Spring pooling and SLSB pooling is that Spring pooling can be applied to any POJO. As with Spring in general, this service can be applied in a non-invasive way.

Spring provides out-of-the-box support for Commons Pool 2.2, which provides a fairly efficient pooling implementation. You’ll need the commons-pool Jar on your application’s classpath to use this feature. It’s also possible to subclass org.springframework.aop.target.AbstractPoolingTargetSourceto support any other pooling API.

[Note] Note

Commons Pool 1.5+ is also supported but deprecated as of Spring Framework 4.2.

Sample configuration is shown below:

								<bean
								id=
								"businessObjectTarget"
								class=
								"com.mycompany.MyBusinessObject"
								scope=
								"prototype"
								>... properties omitted
								</bean>
								<bean
								id=
								"poolTargetSource"
								class=
								"org.springframework.aop.target.CommonsPool2TargetSource"
								>
								<property
								name=
								"targetBeanName"
								value=
								"businessObjectTarget"
								/>
								<property
								name=
								"maxSize"
								value=
								"25"
								/>
								</bean>
								<bean
								id=
								"businessObject"
								class=
								"org.springframework.aop.framework.ProxyFactoryBean"
								>
								<property
								name=
								"targetSource"
								ref=
								"poolTargetSource"
								/>
								<property
								name=
								"interceptorNames"
								value=
								"myInterceptor"
								/>
								</bean>

Note that the target object - "businessObjectTarget" in the example - mustbe a prototype. This allows the PoolingTargetSourceimplementation to create new instances of the target to grow the pool as necessary. See the javadocs of AbstractPoolingTargetSourceand the concrete subclass you wish to use for information about its properties: "maxSize" is the most basic, and always guaranteed to be present.

In this case, "myInterceptor" is the name of an interceptor that would need to be defined in the same IoC context. However, it isn’t necessary to specify interceptors to use pooling. If you want only pooling, and no other advice, don’t set the interceptorNames property at all.

It’s possible to configure Spring so as to be able to cast any pooled object to the org.springframework.aop.target.PoolingConfiginterface, which exposes information about the configuration and current size of the pool through an introduction. You’ll need to define an advisor like this:

								<bean
								id=
								"poolConfigAdvisor"
								class=
								"org.springframework.beans.factory.config.MethodInvokingFactoryBean"
								>
								<property
								name=
								"targetObject"
								ref=
								"poolTargetSource"
								/>
								<property
								name=
								"targetMethod"
								value=
								"getPoolingConfigMixin"
								/>
								</bean>

This advisor is obtained by calling a convenience method on the AbstractPoolingTargetSourceclass, hence the use of MethodInvokingFactoryBean. This advisor’s name ("poolConfigAdvisor" here) must be in the list of interceptors names in the ProxyFactoryBean exposing the pooled object.

The cast will look as follows:

PoolingConfig conf = (PoolingConfig) beanFactory.getBean(
								"businessObject"); System.out.println(
								"Max pool size is "+ conf.getMaxSize());
[Note] Note

Pooling stateless service objects is not usually necessary. We don’t believe it should be the default choice, as most stateless objects are naturally thread safe, and instance pooling is problematic if resources are cached.

Simpler pooling is available using auto-proxying. It’s possible to set the TargetSources used by any auto-proxy creator.

12.10.3 Prototype target sources

Setting up a "prototype" target source is similar to a pooling TargetSource. In this case, a new instance of the target will be created on every method invocation. Although the cost of creating a new object isn’t high in a modern JVM, the cost of wiring up the new object (satisfying its IoC dependencies) may be more expensive. Thus you shouldn’t use this approach without very good reason.

To do this, you could modify the poolTargetSourcedefinition shown above as follows. (I’ve also changed the name, for clarity.)

								<bean
								id=
								"prototypeTargetSource"
								class=
								"org.springframework.aop.target.PrototypeTargetSource"
								>
								<property
								name=
								"targetBeanName"
								ref=
								"businessObjectTarget"
								/>
								</bean>

There’s only one property: the name of the target bean. Inheritance is used in the TargetSource implementations to ensure consistent naming. As with the pooling target source, the target bean must be a prototype bean definition.

12.10.4 ThreadLocal target sources

ThreadLocaltarget sources are useful if you need an object to be created for each incoming request (per thread that is). The concept of a ThreadLocalprovide a JDK-wide facility to transparently store resource alongside a thread. Setting up a ThreadLocalTargetSourceis pretty much the same as was explained for the other types of target source:

								<bean
								id=
								"threadlocalTargetSource"
								class=
								"org.springframework.aop.target.ThreadLocalTargetSource"
								>
								<property
								name=
								"targetBeanName"
								value=
								"businessObjectTarget"
								/>
								</bean>
[Note] Note

ThreadLocals come with serious issues (potentially resulting in memory leaks) when incorrectly using them in a multi-threaded and multi-classloader environments. One should always consider wrapping a threadlocal in some other class and never directly use the ThreadLocalitself (except of course in the wrapper class). Also, one should always remember to correctly set and unset (where the latter simply involved a call to ThreadLocal.set(null)) the resource local to the thread. Unsetting should be done in any case since not unsetting it might result in problematic behavior. Spring’s ThreadLocal support does this for you and should always be considered in favor of using ThreadLocals without other proper handling code.

12.11 Defining new Advice types

Spring AOP is designed to be extensible. While the interception implementation strategy is presently used internally, it is possible to support arbitrary advice types in addition to the out-of-the-box interception around advice, before, throws advice and after returning advice.

The org.springframework.aop.framework.adapterpackage is an SPI package allowing support for new custom advice types to be added without changing the core framework. The only constraint on a custom Advicetype is that it must implement the org.aopalliance.aop.Advicemarker interface.

Please refer to the org.springframework.aop.framework.adapterjavadocs for further information.

12.12 Further resources

Please refer to the Spring sample applications for further examples of Spring AOP:

  • The JPetStore’s default configuration illustrates the use of the TransactionProxyFactoryBeanfor declarative transaction management.
  • The /attributesdirectory of the JPetStore illustrates the use of attribute-driven declarative transaction management.

Part IV. Testing

The adoption of the test-driven-development (TDD) approach to software development is certainly advocated by the Spring team, and so coverage of Spring’s support for integration testing is covered (alongside best practices for unit testing). The Spring team has found that the correct use of IoC certainly does make both unit and integration testing easier (in that the presence of setter methods and appropriate constructors on classes makes them easier to wire together in a test without having to set up service locator registries and suchlike)…​ the chapter dedicated solely to testing will hopefully convince you of this as well.

13. Introduction to Spring Testing

Testing is an integral part of enterprise software development. This chapter focuses on the value-add of the IoC principle to unit testingand on the benefits of the Spring Framework’s support for integration testing. (A thorough treatment of testing in the enterprise is beyond the scope of this reference manual.)

14. Unit Testing

Dependency Injection should make your code less dependent on the container than it would be with traditional Java EE development. The POJOs that make up your application should be testable in JUnit or TestNG tests, with objects simply instantiated using the newoperator, without Spring or any other container. You can use mock objects(in conjunction with other valuable testing techniques) to test your code in isolation. If you follow the architecture recommendations for Spring, the resulting clean layering and componentization of your codebase will facilitate easier unit testing. For example, you can test service layer objects by stubbing or mocking DAO or Repository interfaces, without needing to access persistent data while running unit tests.

True unit tests typically run extremely quickly, as there is no runtime infrastructure to set up. Emphasizing true unit tests as part of your development methodology will boost your productivity. You may not need this section of the testing chapter to help you write effective unit tests for your IoC-based applications. For certain unit testing scenarios, however, the Spring Framework provides the following mock objects and testing support classes.

14.1 Mock Objects

14.1.1 Environment

The org.springframework.mock.envpackage contains mock implementations of the Environmentand PropertySourceabstractions (see Section 7.13.1, “Bean definition profiles”and Section 7.13.3, “PropertySource abstraction”). MockEnvironmentand MockPropertySourceare useful for developing out-of-containertests for code that depends on environment-specific properties.

14.1.2 JNDI

The org.springframework.mock.jndipackage contains an implementation of the JNDI SPI, which you can use to set up a simple JNDI environment for test suites or stand-alone applications. If, for example, JDBC DataSources get bound to the same JNDI names in test code as within a Java EE container, you can reuse both application code and configuration in testing scenarios without modification.

14.1.3 Servlet API

The org.springframework.mock.webpackage contains a comprehensive set of Servlet API mock objects, which are useful for testing web contexts, controllers, and filters. These mock objects are targeted at usage with Spring’s Web MVC framework and are generally more convenient to use than dynamic mock objects such as EasyMockor alternative Servlet API mock objects such as MockObjects. Since Spring Framework 4.0, the set of mocks in the org.springframework.mock.webpackage is based on the Servlet 3.0 API.

For thorough integration testing of your Spring MVC and REST Controllers in conjunction with your WebApplicationContextconfiguration for Spring MVC, see the Spring MVC Test Framework .

14.1.4 Portlet API

The org.springframework.mock.web.portletpackage contains a set of Portlet API mock objects, targeted at usage with Spring’s Portlet MVC framework.

14.2 Unit Testing support Classes

14.2.1 General testing utilities

The org.springframework.test.utilpackage contains several general purpose utilities for use in unit and integration testing.

ReflectionTestUtilsis a collection of reflection-based utility methods. Developers use these methods in testing scenarios where they need to change the value of a constant, set a non- publicfield, invoke a non- publicsetter method, or invoke a non- public configurationor lifecyclecallback method when testing application code involving use cases such as the following.

  • ORM frameworks such as JPA and Hibernate that condone privateor protectedfield access as opposed to publicsetter methods for properties in a domain entity.
  • Spring’s support for annotations such as @Autowired, @Inject, and @Resource, which provides dependency injection for privateor protectedfields, setter methods, and configuration methods.
  • Use of annotations such as @PostConstructand @PreDestroyfor lifecycle callback methods.

AopTestUtilsis a collection of AOP-related utility methods. These methods can be used to obtain a reference to the underlying target object hidden behind one or more Spring proxies. For example, if you have configured a bean as a dynamic mock using a library like EasyMock or Mockito and the mock is wrapped in a Spring proxy, you may need direct access to the underlying mock in order to configure expectations on it and perform verifications. For Spring’s core AOP utilities, see AopUtilsand AopProxyUtils.

14.2.2 Spring MVC

The org.springframework.test.webpackage contains ModelAndViewAssert, which you can use in combination with JUnit, TestNG, or any other testing framework for unit tests dealing with Spring MVC ModelAndViewobjects.

[Tip] Unit testing Spring MVC Controllers

To unit test your Spring MVC Controllers as POJOs, use ModelAndViewAssertcombined with MockHttpServletRequest, MockHttpSession, and so on from Spring’s Servlet API mocks. For thorough integration testing of your Spring MVC and REST Controllers in conjunction with your WebApplicationContextconfiguration for Spring MVC, use the Spring MVC Test Framework instead.

15. Integration Testing

15.1 Overview

It is important to be able to perform some integration testing without requiring deployment to your application server or connecting to other enterprise infrastructure. This will enable you to test things such as:

  • The correct wiring of your Spring IoC container contexts.
  • Data access using JDBC or an ORM tool. This would include such things as the correctness of SQL statements, Hibernate queries, JPA entity mappings, etc.

The Spring Framework provides first-class support for integration testing in the spring-testmodule. The name of the actual JAR file might include the release version and might also be in the long org.springframework.testform, depending on where you get it from (see the section on Dependency Managementfor an explanation). This library includes the org.springframework.testpackage, which contains valuable classes for integration testing with a Spring container. This testing does not rely on an application server or other deployment environment. Such tests are slower to run than unit tests but much faster than the equivalent Selenium tests or remote tests that rely on deployment to an application server.

In Spring 2.5 and later, unit and integration testing support is provided in the form of the annotation-driven Spring TestContext Framework. The TestContext framework is agnostic of the actual testing framework in use, thus allowing instrumentation of tests in various environments including JUnit, TestNG, and so on.

15.2 Goals of Integration Testing

Spring’s integration testing support has the following primary goals:

The next few sections describe each goal and provide links to implementation and configuration details.

15.2.1 Context management and caching

The Spring TestContext Framework provides consistent loading of Spring ApplicationContexts and WebApplicationContexts as well as caching of those contexts. Support for the caching of loaded contexts is important, because startup time can become an issue — not because of the overhead of Spring itself, but because the objects instantiated by the Spring container take time to instantiate. For example, a project with 50 to 100 Hibernate mapping files might take 10 to 20 seconds to load the mapping files, and incurring that cost before running every test in every test fixture leads to slower overall test runs that reduce developer productivity.

Test classes typically declare either an array of resource locationsfor XML or Groovy configuration metadata — often in the classpath — or an array of annotated classesthat is used to configure the application. These locations or classes are the same as or similar to those specified in web.xmlor other configuration files for production deployments.

By default, once loaded, the configured ApplicationContextis reused for each test. Thus the setup cost is incurred only once per test suite, and subsequent test execution is much faster. In this context, the term test suitemeans all tests run in the same JVM — for example, all tests run from an Ant, Maven, or Gradle build for a given project or module. In the unlikely case that a test corrupts the application context and requires reloading — for example, by modifying a bean definition or the state of an application object — the TestContext framework can be configured to reload the configuration and rebuild the application context before executing the next test.

See Section 15.5.4, “Context management”and the section called “Context caching”with the TestContext framework.

15.2.2 Dependency Injection of test fixtures

When the TestContext framework loads your application context, it can optionally configure instances of your test classes via Dependency Injection. This provides a convenient mechanism for setting up test fixtures using preconfigured beans from your application context. A strong benefit here is that you can reuse application contexts across various testing scenarios (e.g., for configuring Spring-managed object graphs, transactional proxies, DataSources, etc.), thus avoiding the need to duplicate complex test fixture setup for individual test cases.

As an example, consider the scenario where we have a class, HibernateTitleRepository, that implements data access logic for a Titledomain entity. We want to write integration tests that test the following areas:

  • The Spring configuration: basically, is everything related to the configuration of the HibernateTitleRepositorybean correct and present?
  • The Hibernate mapping file configuration: is everything mapped correctly, and are the correct lazy-loading settings in place?
  • The logic of the HibernateTitleRepository: does the configured instance of this class perform as anticipated?

See dependency injection of test fixtures with the TestContext framework.

15.2.3 Transaction management

One common issue in tests that access a real database is their effect on the state of the persistence store. Even when you’re using a development database, changes to the state may affect future tests. Also, many operations — such as inserting or modifying persistent data — cannot be performed (or verified) outside a transaction.

The TestContext framework addresses this issue. By default, the framework will create and roll back a transaction for each test. You simply write code that can assume the existence of a transaction. If you call transactionally proxied objects in your tests, they will behave correctly, according to their configured transactional semantics. In addition, if a test method deletes the contents of selected tables while running within the transaction managed for the test, the transaction will roll back by default, and the database will return to its state prior to execution of the test. Transactional support is provided to a test via a PlatformTransactionManagerbean defined in the test’s application context.

If you want a transaction to commit — unusual, but occasionally useful when you want a particular test to populate or modify the database — the TestContext framework can be instructed to cause the transaction to commit instead of roll back via the @Commitannotation.

See transaction management with the TestContext framework.

15.2.4 Support classes for integration testing

The Spring TestContext Framework provides several abstractsupport classes that simplify the writing of integration tests. These base test classes provide well-defined hooks into the testing framework as well as convenient instance variables and methods, which enable you to access:

  • The ApplicationContext, for performing explicit bean lookups or testing the state of the context as a whole.
  • A JdbcTemplate, for executing SQL statements to query the database. Such queries can be used to confirm database state both prior toand afterexecution of database-related application code, and Spring ensures that such queries run in the scope of the same transaction as the application code. When used in conjunction with an ORM tool, be sure to avoid false positives.

In addition, you may want to create your own custom, application-wide superclass with instance variables and methods specific to your project.

See support classes for the TestContext framework.

15.3 JDBC Testing Support

The org.springframework.test.jdbcpackage contains JdbcTestUtils, which is a collection of JDBC related utility functions intended to simplify standard database testing scenarios. Specifically, JdbcTestUtilsprovides the following static utility methods.

  • countRowsInTable(..): counts the number of rows in the given table
  • countRowsInTableWhere(..): counts the number of rows in the given table, using the provided WHEREclause
  • deleteFromTables(..): deletes all rows from the specified tables
  • deleteFromTableWhere(..): deletes rows from the given table, using the provided WHEREclause
  • dropTables(..): drops the specified tables

Note that AbstractTransactionalJUnit4SpringContextTestsand AbstractTransactionalTestNGSpringContextTestsprovide convenience methods which delegate to the aforementioned methods in JdbcTestUtils.

The spring-jdbcmodule provides support for configuring and launching an embedded database which can be used in integration tests that interact with a database. For details, see Section 19.8, “Embedded database support”and Section 19.8.5, “Testing data access logic with an embedded database”.

15.4 Annotations

15.4.1 Spring Testing Annotations

The Spring Framework provides the following set of Spring-specificannotations that you can use in your unit and integration tests in conjunction with the TestContext framework. Refer to the corresponding javadocs for further information, including default attribute values, attribute aliases, and so on.

@BootstrapWith

@BootstrapWithis a class-level annotation that is used to configure how the Spring TestContext Frameworkis bootstrapped. Specifically, @BootstrapWithis used to specify a custom TestContextBootstrapper. Consult the Bootstrapping the TestContext frameworksection for further details.

@ContextConfiguration

@ContextConfigurationdefines class-level metadata that is used to determine how to load and configure an ApplicationContextfor integration tests. Specifically, @ContextConfigurationdeclares the application context resource locationsor the annotated classesthat will be used to load the context.

Resource locations are typically XML configuration files or Groovy scripts located in the classpath; whereas, annotated classes are typically @Configurationclasses. However, resource locations can also refer to files and scripts in the file system, and annotated classes can be component classes, etc.

									
										@ContextConfiguration(
									"/test-config.xml")
									public
									classXmlApplicationContextTests {
									// class body...}
									
										@ContextConfiguration(
									
										classes= TestConfig.
									class)
									public
									classConfigClassApplicationContextTests {
									// class body...}

As an alternative or in addition to declaring resource locations or annotated classes, @ContextConfigurationmay be used to declare ApplicationContextInitializerclasses.

									
										@ContextConfiguration(
									
										initializers= CustomContextIntializer.
									class)
									public
									classContextInitializerTests {
									// class body...}

@ContextConfigurationmay optionally be used to declare the ContextLoaderstrategy as well. Note, however, that you typically do not need to explicitly configure the loader since the default loader supports either resource locationsor annotated classesas well as initializers.

									
										@ContextConfiguration(
									
										locations=
									"/test-context.xml",
									
										loader= CustomContextLoader.
									class)
									public
									classCustomLoaderXmlApplicationContextTests {
									// class body...}
[Note] Note

@ContextConfigurationprovides support for inheritingresource locations or configuration classes as well as context initializers declared by superclasses by default.

See Section 15.5.4, “Context management”and the @ContextConfigurationjavadocs for further details.

@WebAppConfiguration

@WebAppConfigurationis a class-level annotation that is used to declare that the ApplicationContextloaded for an integration test should be a WebApplicationContext. The mere presence of @WebAppConfigurationon a test class ensures that a WebApplicationContextwill be loaded for the test, using the default value of "file:src/main/webapp"for the path to the root of the web application (i.e., the resource base path). The resource base path is used behind the scenes to create a MockServletContextwhich serves as the ServletContextfor the test’s WebApplicationContext.

									
										@ContextConfiguration
									
										@WebAppConfiguration
									public
									classWebAppTests {
									// class body...}

To override the default, specify a different base resource path via the implicit valueattribute. Both classpath:and file:resource prefixes are supported. If no resource prefix is supplied the path is assumed to be a file system resource.

									
										@ContextConfiguration
									
										@WebAppConfiguration("classpath:test-web-resources")
									public
									classWebAppTests {
									// class body...}

Note that @WebAppConfigurationmust be used in conjunction with @ContextConfiguration, either within a single test class or within a test class hierarchy. See the @WebAppConfigurationjavadocs for further details.

@ContextHierarchy

@ContextHierarchyis a class-level annotation that is used to define a hierarchy of ApplicationContexts for integration tests. @ContextHierarchyshould be declared with a list of one or more @ContextConfigurationinstances, each of which defines a level in the context hierarchy. The following examples demonstrate the use of @ContextHierarchywithin a single test class; however, @ContextHierarchycan also be used within a test class hierarchy.

									
										@ContextHierarchy({ @ContextConfiguration("/parent-config.xml"), @ContextConfiguration("/child-config.xml") })
									public
									classContextHierarchyTests {
									// class body...}
									
										@WebAppConfiguration
									
										@ContextHierarchy({ @ContextConfiguration(classes = AppConfig.class), @ContextConfiguration(classes = WebConfig.class) })
									public
									classWebIntegrationTests {
									// class body...}

If you need to merge or override the configuration for a given level of the context hierarchy within a test class hierarchy, you must explicitly name that level by supplying the same value to the nameattribute in @ContextConfigurationat each corresponding level in the class hierarchy. See the section called “Context hierarchies”and the @ContextHierarchyjavadocs for further examples.

@ActiveProfiles

@ActiveProfilesis a class-level annotation that is used to declare which bean definition profilesshould be active when loading an ApplicationContextfor an integration test.

									
										@ContextConfiguration
									
										@ActiveProfiles(
									"dev")
									public
									classDeveloperTests {
									// class body...}
									
										@ContextConfiguration
									
										@ActiveProfiles({
									"dev",
									"integration"})
									public
									classDeveloperIntegrationTests {
									// class body...}
[Note] Note

@ActiveProfilesprovides support for inheritingactive bean definition profiles declared by superclasses by default. It is also possible to resolve active bean definition profiles programmatically by implementing a custom ActiveProfilesResolverand registering it via the resolverattribute of @ActiveProfiles.

See the section called “Context configuration with environment profiles”and the @ActiveProfilesjavadocs for examples and further details.

@TestPropertySource

@TestPropertySourceis a class-level annotation that is used to configure the locations of properties files and inlined properties to be added to the set of PropertySourcesin the Environmentfor an ApplicationContextloaded for an integration test.

Test property sources have higher precedence than those loaded from the operating system’s environment or Java system properties as well as property sources added by the application declaratively via @PropertySourceor programmatically. Thus, test property sources can be used to selectively override properties defined in system and application property sources. Furthermore, inlined properties have higher precedence than properties loaded from resource locations.

The following example demonstrates how to declare a properties file from the classpath.

									
										@ContextConfiguration
									
										@TestPropertySource(
									"/test.properties")
									public
									classMyIntegrationTests {
									// class body...}

The following example demonstrates how to declare inlinedproperties.

									
										@ContextConfiguration
									
										@TestPropertySource(properties = {
									"timezone = GMT",
									"port: 4242"})
									public
									classMyIntegrationTests {
									// class body...}

@DirtiesContext

@DirtiesContextindicates that the underlying Spring ApplicationContexthas been dirtiedduring the execution of a test (i.e., modified or corrupted in some manner — for example, by changing the state of a singleton bean) and should be closed. When an application context is marked dirty, it is removed from the testing framework’s cache and closed. As a consequence, the underlying Spring container will be rebuilt for any subsequent test that requires a context with the same configuration metadata.

@DirtiesContextcan be used as both a class-level and method-level annotation within the same class or class hierarchy. In such scenarios, the ApplicationContextis marked as dirtybefore or after any such annotated method as well as before or after the current test class, depending on the configured methodModeand classMode.

The following examples explain when the context would be dirtied for various configuration scenarios:

  • Before the current test class, when declared on a class with class mode set to BEFORE_CLASS.

    												
													@DirtiesContext(classMode = BEFORE_CLASS)
												public
												classFreshContextTests {
												// some tests that require a new Spring container}

  • After the current test class, when declared on a class with class mode set to AFTER_CLASS(i.e., the default class mode).

    												
													@DirtiesContext
												public
												classContextDirtyingTests {
												// some tests that result in the Spring container being dirtied}

  • Before each test method in the current test class, when declared on a class with class mode set to BEFORE_EACH_TEST_METHOD.

    												
													@DirtiesContext(classMode = BEFORE_EACH_TEST_METHOD)
												public
												classFreshContextTests {
												// some tests that require a new Spring container}

  • After each test method in the current test class, when declared on a class with class mode set to AFTER_EACH_TEST_METHOD.

    												
													@DirtiesContext(classMode = AFTER_EACH_TEST_METHOD)
												public
												classContextDirtyingTests {
												// some tests that result in the Spring container being dirtied}

  • Before the current test, when declared on a method with the method mode set to BEFORE_METHOD.

    												
													@DirtiesContext(methodMode = BEFORE_METHOD)
												
													@Test
												public
												voidtestProcessWhichRequiresFreshAppCtx() {
												// some logic that requires a new Spring container}

  • After the current test, when declared on a method with the method mode set to AFTER_METHOD(i.e., the default method mode).

    												
													@DirtiesContext
												
													@Test
												public
												voidtestProcessWhichDirtiesAppCtx() {
												// some logic that results in the Spring container being dirtied}

If @DirtiesContextis used in a test whose context is configured as part of a context hierarchy via @ContextHierarchy, the hierarchyModeflag can be used to control how the context cache is cleared. By default an exhaustivealgorithm will be used that clears the context cache including not only the current level but also all other context hierarchies that share an ancestor context common to the current test; all ApplicationContexts that reside in a sub-hierarchy of the common ancestor context will be removed from the context cache and closed. If the exhaustivealgorithm is overkill for a particular use case, the simpler current levelalgorithm can be specified instead, as seen below.

									
										@ContextHierarchy({ @ContextConfiguration("/parent-config.xml"), @ContextConfiguration("/child-config.xml") })
									public
									classBaseTests {
									// class body...}
									public
									classExtendedTests
									extendsBaseTests {
									
										@Test@DirtiesContext(
									
										hierarchyMode = CURRENT_LEVEL)
									public
									voidtest() {
									// some logic that results in the child context being dirtied} }

For further details regarding the EXHAUSTIVEand CURRENT_LEVELalgorithms see the DirtiesContext.HierarchyModejavadocs.

@TestExecutionListeners

@TestExecutionListenersdefines class-level metadata for configuring the TestExecutionListenerimplementations that should be registered with the TestContextManager. Typically, @TestExecutionListenersis used in conjunction with @ContextConfiguration.

									
										@ContextConfiguration
									
										@TestExecutionListeners({CustomTestExecutionListener.
									class, AnotherTestExecutionListener.
									class})
									public
									classCustomTestExecutionListenerTests {
									// class body...}

@TestExecutionListenerssupports inheritedlisteners by default. See the javadocs for an example and further details.

@Commit

@Commitindicates that the transaction for a transactional test method should be committedafter the test method has completed. @Commitcan be used as a direct replacement for @Rollback(false)in order to more explicitly convey the intent of the code. Analogous to @Rollback, @Commitmay also be declared as a class-level or method-level annotation.

									
										@Commit
									
										@Test
									public
									voidtestProcessWithoutRollback() {
									// ...}

@Rollback

@Rollbackindicates whether the transaction for a transactional test method should be rolled backafter the test method has completed. If true, the transaction is rolled back; otherwise, the transaction is committed (see also @Commit). Rollback semantics for integration tests in the Spring TestContext Framework default to trueeven if @Rollbackis not explicitly declared.

When declared as a class-level annotation, @Rollbackdefines the default rollback semantics for all test methods within the test class hierarchy. When declared as a method-level annotation, @Rollbackdefines rollback semantics for the specific test method, potentially overriding class-level @Rollbackor @Commitsemantics.

									
										@Rollback(false)
									
										@Test
									public
									voidtestProcessWithoutRollback() {
									// ...}

@BeforeTransaction

@BeforeTransactionindicates that the annotated voidmethod should be executed beforea transaction is started for test methods configured to run within a transaction via Spring’s @Transactionalannotation. As of Spring Framework 4.3, @BeforeTransactionmethods are not required to be publicand may be declared on Java 8 based interface default methods.

									
										@BeforeTransaction
									voidbeforeTransaction() {
									// logic to be executed before a transaction is started}

@AfterTransaction

@AfterTransactionindicates that the annotated voidmethod should be executed aftera transaction is ended for test methods configured to run within a transaction via Spring’s @Transactionalannotation. As of Spring Framework 4.3, @AfterTransactionmethods are not required to be publicand may be declared on Java 8 based interface default methods.

									
										@AfterTransaction
									voidafterTransaction() {
									// logic to be executed after a transaction has ended}

@Sql

@Sqlis used to annotate a test class or test method to configure SQL scripts to be executed against a given database during integration tests.

									
										@Test
									
										@Sql({
									"/test-schema.sql",
									"/test-user-data.sql"})
									public
									voiduserTest {
									// execute code that relies on the test schema and test data}

See the section called “Executing SQL scripts declaratively with @Sql”for further details.

@SqlConfig

@SqlConfigdefines metadata that is used to determine how to parse and execute SQL scripts configured via the @Sqlannotation.

									
										@Test@Sql( scripts =
									"/test-user-data.sql", config =
									
										@SqlConfig(commentPrefix =
									"`", separator =
									"@@") )
									public
									voiduserTest {
									// execute code that relies on the test data}

@SqlGroup

@SqlGroupis a container annotation that aggregates several @Sqlannotations. @SqlGroupcan be used natively, declaring several nested @Sqlannotations, or it can be used in conjunction with Java 8’s support for repeatable annotations, where @Sqlcan simply be declared several times on the same class or method, implicitly generating this container annotation.

									
										@Test
									
										@SqlGroup({
									
										@Sql(scripts = "/test-schema.sql", config = @SqlConfig(commentPrefix = "`")),
									
										@Sql("/test-user-data.sql"))}
									public
									voiduserTest {
									// execute code that uses the test schema and test data}

15.4.2 Standard Annotation Support

The following annotations are supported with standard semantics for all configurations of the Spring TestContext Framework. Note that these annotations are not specific to tests and can be used anywhere in the Spring Framework.

  • @Autowired
  • @Qualifier
  • @Resource(javax.annotation) if JSR-250 is present
  • @ManagedBean(javax.annotation) if JSR-250 is present
  • @Inject(javax.inject) if JSR-330 is present
  • @Named(javax.inject) if JSR-330 is present
  • @PersistenceContext(javax.persistence) if JPA is present
  • @PersistenceUnit(javax.persistence) if JPA is present
  • @Required
  • @Transactional
[Note] JSR-250 Lifecycle Annotations

In the Spring TestContext Framework @PostConstructand @PreDestroymay be used with standard semantics on any application components configured in the ApplicationContext; however, these lifecycle annotations have limited usage within an actual test class.

If a method within a test class is annotated with @PostConstruct, that method will be executed before any beforemethods of the underlying test framework (e.g., methods annotated with JUnit 4’s @Before), and that will apply for every test method in the test class. On the other hand, if a method within a test class is annotated with @PreDestroy, that method will neverbe executed. Within a test class it is therefore recommended to use test lifecycle callbacks from the underlying test framework instead of @PostConstructand @PreDestroy.

15.4.3 Spring JUnit 4 Testing Annotations

The following annotations are onlysupported when used in conjunction with the SpringRunner, Spring’s JUnit rules, or Spring’s JUnit 4 support classes.

@IfProfileValue

@IfProfileValueindicates that the annotated test is enabled for a specific testing environment. If the configured ProfileValueSourcereturns a matching valuefor the provided name, the test is enabled. Otherwise, the test will be disabled and effectively ignored.

@IfProfileValuecan be applied at the class level, the method level, or both. Class-level usage of @IfProfileValuetakes precedence over method-level usage for any methods within that class or its subclasses. Specifically, a test is enabled if it is enabled both at the class level andat the method level; the absence of @IfProfileValuemeans the test is implicitly enabled. This is analogous to the semantics of JUnit 4’s @Ignoreannotation, except that the presence of @Ignorealways disables a test.

									
										@IfProfileValue(
									
										name=
									"java.vendor",
									
										value=
									"Oracle Corporation")
									
										@Test
									public
									voidtestProcessWhichRunsOnlyOnOracleJvm() {
									// some logic that should run only on Java VMs from Oracle Corporation}

Alternatively, you can configure @IfProfileValuewith a list of values(with ORsemantics) to achieve TestNG-like support for test groupsin a JUnit 4 environment. Consider the following example:

									
										@IfProfileValue(
									
										name=
									"test-groups",
									
										values={
									"unit-tests",
									"integration-tests"})
									
										@Test
									public
									voidtestProcessWhichRunsForUnitOrIntegrationTestGroups() {
									// some logic that should run only for unit and integration test groups}

@ProfileValueSourceConfiguration

@ProfileValueSourceConfigurationis a class-level annotation that specifies what type of ProfileValueSourceto use when retrieving profile valuesconfigured through the @IfProfileValueannotation. If @ProfileValueSourceConfigurationis not declared for a test, SystemProfileValueSourceis used by default.

									
										@ProfileValueSourceConfiguration(CustomProfileValueSource.
									class)
									public
									classCustomProfileValueSourceTests {
									// class body...}

@Timed

@Timedindicates that the annotated test method must finish execution in a specified time period (in milliseconds). If the text execution time exceeds the specified time period, the test fails.

The time period includes execution of the test method itself, any repetitions of the test (see @Repeat), as well as any set upor tear downof the test fixture.

									
										@Timed(millis=
									1000)
									public
									voidtestProcessWithOneSecondTimeout() {
									// some logic that should not take longer than 1 second to execute}

Spring’s @Timedannotation has different semantics than JUnit 4’s @Test(timeout=…​)support. Specifically, due to the manner in which JUnit 4 handles test execution timeouts (that is, by executing the test method in a separate Thread), @Test(timeout=…​)preemptively fails the test if the test takes too long. Spring’s @Timed, on the other hand, does not preemptively fail the test but rather waits for the test to complete before failing.

@Repeat

@Repeatindicates that the annotated test method must be executed repeatedly. The number of times that the test method is to be executed is specified in the annotation.

The scope of execution to be repeated includes execution of the test method itself as well as any set upor tear downof the test fixture.

									
										@Repeat(
									10)
									
										@Test
									public
									voidtestProcessRepeatedly() {
									// ...}

15.4.4 Meta-Annotation Support for Testing

It is possible to use most test-related annotations as meta-annotationsin order to create custom composed annotationsand reduce configuration duplication across a test suite.

Each of the following may be used as meta-annotations in conjunction with the TestContext framework.

  • @BootstrapWith
  • @ContextConfiguration
  • @ContextHierarchy
  • @ActiveProfiles
  • @TestPropertySource
  • @DirtiesContext
  • @WebAppConfiguration
  • @TestExecutionListeners
  • @Transactional
  • @BeforeTransaction
  • @AfterTransaction
  • @Commit
  • @Rollback
  • @Sql
  • @SqlConfig
  • @SqlGroup
  • @Repeat
  • @Timed
  • @IfProfileValue
  • @ProfileValueSourceConfiguration

For example, if we discover that we are repeating the following configuration across our JUnit 4 based test suite…​

								
									@RunWith(SpringRunner.class)
								
									@ContextConfiguration({"/app-config.xml", "/test-data-access-config.xml"})
								
									@ActiveProfiles("dev")
								
									@Transactional
								public
								classOrderRepositoryTests { }
								
									@RunWith(SpringRunner.class)
								
									@ContextConfiguration({"/app-config.xml", "/test-data-access-config.xml"})
								
									@ActiveProfiles("dev")
								
									@Transactional
								public
								classUserRepositoryTests { }

We can reduce the above duplication by introducing a custom composed annotationthat centralizes the common test configuration like this:

								
									@Target(ElementType.TYPE)
								
									@Retention(RetentionPolicy.RUNTIME)
								
									@ContextConfiguration({"/app-config.xml", "/test-data-access-config.xml"})
								
									@ActiveProfiles("dev")
								
									@Transactional
								public
								
									@interfaceTransactionalDevTest { }

Then we can use our custom @TransactionalDevTestannotation to simplify the configuration of individual test classes as follows:

								
									@RunWith(SpringRunner.class)
								
									@TransactionalDevTest
								public
								classOrderRepositoryTests { }
								
									@RunWith(SpringRunner.class)
								
									@TransactionalDevTest
								public
								classUserRepositoryTests { }

For further details, consult the Spring Annotation Programming Model.

15.5 Spring TestContext Framework

The Spring TestContext Framework(located in the org.springframework.test.contextpackage) provides generic, annotation-driven unit and integration testing support that is agnostic of the testing framework in use. The TestContext framework also places a great deal of importance on convention over configurationwith reasonable defaults that can be overridden through annotation-based configuration.

In addition to generic testing infrastructure, the TestContext framework provides explicit support for JUnit 4 and TestNG in the form of abstractsupport classes. For JUnit 4, Spring also provides a custom JUnit Runnerand custom JUnit Rulesthat allow one to write so-called POJO test classes. POJO test classes are not required to extend a particular class hierarchy.

The following section provides an overview of the internals of the TestContext framework. If you are only interested in usingthe framework and not necessarily interested in extendingit with your own custom listeners or custom loaders, feel free to go directly to the configuration ( context management, dependency injection, transaction management), support classes, and annotation supportsections.

15.5.1 Key abstractions

The core of the framework consists of the TestContextManagerclass and the TestContext, TestExecutionListener, and SmartContextLoaderinterfaces. A TestContextManageris created per test class (e.g., for the execution of all test methods within a single test class in JUnit 4). The TestContextManagerin turn manages a TestContextthat holds the context of the current test. The TestContextManageralso updates the state of the TestContextas the test progresses and delegates to TestExecutionListenerimplementations, which instrument the actual test execution by providing dependency injection, managing transactions, and so on. A SmartContextLoaderis responsible for loading an ApplicationContextfor a given test class. Consult the javadocs and the Spring test suite for further information and examples of various implementations.

TestContext

TestContextencapsulates the context in which a test is executed, agnostic of the actual testing framework in use, and provides context management and caching support for the test instance for which it is responsible. The TestContextalso delegates to a SmartContextLoaderto load an ApplicationContextif requested.

TestContextManager

TestContextManageris the main entry point into the Spring TestContext Framework, which manages a single TestContextand signals events to each registered TestExecutionListenerat well-defined test execution points:

  • prior to any before classor before allmethods of a particular testing framework
  • test instance post-processing
  • prior to any beforeor before eachmethods of a particular testing framework
  • after any afteror after eachmethods of a particular testing framework
  • after any after classor after allmethods of a particular testing framework

TestExecutionListener

TestExecutionListenerdefines the API for reacting to test execution events published by the TestContextManagerwith which the listener is registered. See Section 15.5.3, “TestExecutionListener configuration”.

Context Loaders

ContextLoaderis a strategy interface that was introduced in Spring 2.5 for loading an ApplicationContextfor an integration test managed by the Spring TestContext Framework. Implement SmartContextLoaderinstead of this interface in order to provide support for annotated classes, active bean definition profiles, test property sources, context hierarchies, and WebApplicationContextsupport.

SmartContextLoaderis an extension of the ContextLoaderinterface introduced in Spring 3.1. The SmartContextLoaderSPI supersedes the ContextLoaderSPI that was introduced in Spring 2.5. Specifically, a SmartContextLoadercan choose to process resource locations, annotated classes, or context initializers. Furthermore, a SmartContextLoadercan set active bean definition profiles and test property sources in the context that it loads.

Spring provides the following implementations:

  • DelegatingSmartContextLoader: one of two default loaders which delegates internally to an AnnotationConfigContextLoader, a GenericXmlContextLoader, or a GenericGroovyXmlContextLoaderdepending either on the configuration declared for the test class or on the presence of default locations or default configuration classes. Groovy support is only enabled if Groovy is on the classpath.
  • WebDelegatingSmartContextLoader: one of two default loaders which delegates internally to an AnnotationConfigWebContextLoader, a GenericXmlWebContextLoader, or a GenericGroovyXmlWebContextLoaderdepending either on the configuration declared for the test class or on the presence of default locations or default configuration classes. A web ContextLoaderwill only be used if @WebAppConfigurationis present on the test class. Groovy support is only enabled if Groovy is on the classpath.
  • AnnotationConfigContextLoader: loads a standard ApplicationContextfrom annotated classes.
  • AnnotationConfigWebContextLoader: loads a WebApplicationContextfrom annotated classes.
  • GenericGroovyXmlContextLoader: loads a standard ApplicationContextfrom resource locationsthat are either Groovy scripts or XML configuration files.
  • GenericGroovyXmlWebContextLoader: loads a WebApplicationContextfrom resource locationsthat are either Groovy scripts or XML configuration files.
  • GenericXmlContextLoader: loads a standard ApplicationContextfrom XML resource locations.
  • GenericXmlWebContextLoader: loads a WebApplicationContextfrom XML resource locations.
  • GenericPropertiesContextLoader: loads a standard ApplicationContextfrom Java Properties files.

15.5.2 Bootstrapping the TestContext framework

The default configuration for the internals of the Spring TestContext Framework is sufficient for all common use cases. However, there are times when a development team or third party framework would like to change the default ContextLoader, implement a custom TestContextor ContextCache, augment the default sets of ContextCustomizerFactoryand TestExecutionListenerimplementations, etc. For such low level control over how the TestContext framework operates, Spring provides a bootstrapping strategy.

TestContextBootstrapperdefines the SPI for bootstrappingthe TestContext framework. A TestContextBootstrapperis used by the TestContextManagerto load the TestExecutionListenerimplementations for the current test and to build the TestContextthat it manages. A custom bootstrapping strategy can be configured for a test class (or test class hierarchy) via @BootstrapWith, either directly or as a meta-annotation. If a bootstrapper is not explicitly configured via @BootstrapWith, either the DefaultTestContextBootstrapperor the WebTestContextBootstrapperwill be used, depending on the presence of @WebAppConfiguration.

Since the TestContextBootstrapperSPI is likely to change in the future in order to accommodate new requirements, implementers are strongly encouraged not to implement this interface directly but rather to extend AbstractTestContextBootstrapperor one of its concrete subclasses instead.

15.5.3 TestExecutionListener configuration

Spring provides the following TestExecutionListenerimplementations that are registered by default, exactly in this order.

  • ServletTestExecutionListener: configures Servlet API mocks for a WebApplicationContext
  • DirtiesContextBeforeModesTestExecutionListener: handles the @DirtiesContextannotation for beforemodes
  • DependencyInjectionTestExecutionListener: provides dependency injection for the test instance
  • DirtiesContextTestExecutionListener: handles the @DirtiesContextannotation for aftermodes
  • TransactionalTestExecutionListener: provides transactional test execution with default rollback semantics
  • SqlScriptsTestExecutionListener: executes SQL scripts configured via the @Sqlannotation

Registering custom TestExecutionListeners

Custom TestExecutionListeners can be registered for a test class and its subclasses via the @TestExecutionListenersannotation. See annotation supportand the javadocs for @TestExecutionListenersfor details and examples.

Automatic discovery of default TestExecutionListeners

Registering custom TestExecutionListeners via @TestExecutionListenersis suitable for custom listeners that are used in limited testing scenarios; however, it can become cumbersome if a custom listener needs to be used across a test suite. Since Spring Framework 4.1, this issue is addressed via support for automatic discovery of default TestExecutionListenerimplementations via the SpringFactoriesLoadermechanism.

Specifically, the spring-testmodule declares all core default TestExecutionListeners under the org.springframework.test.context.TestExecutionListenerkey in its META-INF/spring.factoriesproperties file. Third-party frameworks and developers can contribute their own TestExecutionListeners to the list of default listeners in the same manner via their own META-INF/spring.factoriesproperties file.

Ordering TestExecutionListeners

When the TestContext framework discovers default TestExecutionListeners via the aforementioned SpringFactoriesLoadermechanism, the instantiated listeners are sorted using Spring’s AnnotationAwareOrderComparatorwhich honors Spring’s Orderedinterface and @Orderannotation for ordering. AbstractTestExecutionListenerand all default TestExecutionListeners provided by Spring implement Orderedwith appropriate values. Third-party frameworks and developers should therefore make sure that their default TestExecutionListeners are registered in the proper order by implementing Orderedor declaring @Order. Consult the javadocs for the getOrder()methods of the core default TestExecutionListeners for details on what values are assigned to each core listener.

Merging TestExecutionListeners

If a custom TestExecutionListeneris registered via @TestExecutionListeners, the defaultlisteners will not be registered. In most common testing scenarios, this effectively forces the developer to manually declare all default listeners in addition to any custom listeners. The following listing demonstrates this style of configuration.

									
										@ContextConfiguration
									
										@TestExecutionListeners({ MyCustomTestExecutionListener.class, ServletTestExecutionListener.class, DirtiesContextBeforeModesTestExecutionListener.class, DependencyInjectionTestExecutionListener.class, DirtiesContextTestExecutionListener.class, TransactionalTestExecutionListener.class, SqlScriptsTestExecutionListener.class })
									public
									classMyTest {
									// class body...}

The challenge with this approach is that it requires that the developer know exactly which listeners are registered by default. Moreover, the set of default listeners can change from release to release — for example, SqlScriptsTestExecutionListenerwas introduced in Spring Framework 4.1, and DirtiesContextBeforeModesTestExecutionListenerwas introduced in Spring Framework 4.2. Furthermore, third-party frameworks like Spring Security register their own default TestExecutionListeners via the aforementioned automatic discovery mechanism.

To avoid having to be aware of and re-declare all defaultlisteners, the mergeModeattribute of @TestExecutionListenerscan be set to MergeMode.MERGE_WITH_DEFAULTS. MERGE_WITH_DEFAULTSindicates that locally declared listeners should be merged with the default listeners. The merging algorithm ensures that duplicates are removed from the list and that the resulting set of merged listeners is sorted according to the semantics of AnnotationAwareOrderComparatoras described in the section called “Ordering TestExecutionListeners”. If a listener implements Orderedor is annotated with @Orderit can influence the position in which it is merged with the defaults; otherwise, locally declared listeners will simply be appended to the list of default listeners when merged.

For example, if the MyCustomTestExecutionListenerclass in the previous example configures its ordervalue (for example, 500) to be less than the order of the ServletTestExecutionListener(which happens to be 1000), the MyCustomTestExecutionListenercan then be automatically merged with the list of defaults in front ofthe ServletTestExecutionListener, and the previous example could be replaced with the following.

									
										@ContextConfiguration
									
										@TestExecutionListeners( listeners = MyCustomTestExecutionListener.class, mergeMode = MERGE_WITH_DEFAULTS )
									public
									classMyTest {
									// class body...}

15.5.4 Context management

Each TestContextprovides context management and caching support for the test instance it is responsible for. Test instances do not automatically receive access to the configured ApplicationContext. However, if a test class implements the ApplicationContextAwareinterface, a reference to the ApplicationContextis supplied to the test instance. Note that AbstractJUnit4SpringContextTestsand AbstractTestNGSpringContextTestsimplement ApplicationContextAwareand therefore provide access to the ApplicationContextautomatically.

[Tip] @Autowired ApplicationContext

As an alternative to implementing the ApplicationContextAwareinterface, you can inject the application context for your test class through the @Autowiredannotation on either a field or setter method. For example:

												
													@RunWith(SpringRunner.class)
												
													@ContextConfiguration
												public
												classMyTest {
												
													@Autowired
												privateApplicationContext applicationContext;
												// class body...}

Similarly, if your test is configured to load a WebApplicationContext, you can inject the web application context into your test as follows:

												
													@RunWith(SpringRunner.class)
												
													@WebAppConfiguration
												
													@ContextConfiguration
												public
												classMyWebAppTest {
												
													@Autowired
												privateWebApplicationContext wac;
												// class body...}

Dependency injection via @Autowiredis provided by the DependencyInjectionTestExecutionListenerwhich is configured by default (see Section 15.5.5, “Dependency injection of test fixtures”).

Test classes that use the TestContext framework do not need to extend any particular class or implement a specific interface to configure their application context. Instead, configuration is achieved simply by declaring the @ContextConfigurationannotation at the class level. If your test class does not explicitly declare application context resource locationsor annotated classes, the configured ContextLoaderdetermines how to load a context from a default location or default configuration classes. In addition to context resource locationsand annotated classes, an application context can also be configured via application context initializers.

The following sections explain how to configure an ApplicationContextvia XML configuration files, Groovy scripts, annotated classes (typically @Configurationclasses), or context initializers using Spring’s @ContextConfigurationannotation. Alternatively, you can implement and configure your own custom SmartContextLoaderfor advanced use cases.

Context configuration with XML resources

To load an ApplicationContextfor your tests using XML configuration files, annotate your test class with @ContextConfigurationand configure the locationsattribute with an array that contains the resource locations of XML configuration metadata. A plain or relative path — for example "context.xml" — will be treated as a classpath resource that is relative to the package in which the test class is defined. A path starting with a slash is treated as an absolute classpath location, for example "/org/example/config.xml". A path which represents a resource URL (i.e., a path prefixed with classpath:, file:, http:, etc.) will be used as is.

									
										@RunWith(SpringRunner.class)
									// ApplicationContext will be loaded from "/app-config.xml" and
									// "/test-config.xml" in the root of the classpath
									
										@ContextConfiguration(locations={"/app-config.xml", "/test-config.xml"})
									public
									classMyTest {
									// class body...}

@ContextConfigurationsupports an alias for the locationsattribute through the standard Java valueattribute. Thus, if you do not need to declare additional attributes in @ContextConfiguration, you can omit the declaration of the locationsattribute name and declare the resource locations by using the shorthand format demonstrated in the following example.

									
										@RunWith(SpringRunner.class)
									
										@ContextConfiguration({"/app-config.xml", "/test-config.xml"})
									public
									classMyTest {
									// class body...}

If you omit both the locationsand valueattributes from the @ContextConfigurationannotation, the TestContext framework will attempt to detect a default XML resource location. Specifically, GenericXmlContextLoaderand GenericXmlWebContextLoaderdetect a default location based on the name of the test class. If your class is named com.example.MyTest, GenericXmlContextLoaderloads your application context from "classpath:com/example/MyTest-context.xml".

									packagecom.example;
									
										@RunWith(SpringRunner.class)
									// ApplicationContext will be loaded from
									// "classpath:com/example/MyTest-context.xml"
									
										@ContextConfiguration
									public
									classMyTest {
									// class body...}

Context configuration with Groovy scripts

To load an ApplicationContextfor your tests using Groovy scripts that utilize the Groovy Bean Definition DSL, annotate your test class with @ContextConfigurationand configure the locationsor valueattribute with an array that contains the resource locations of Groovy scripts. Resource lookup semantics for Groovy scripts are the same as those described for XML configuration files.

[Tip] Enabling Groovy script support

Support for using Groovy scripts to load an ApplicationContextin the Spring TestContext Framework is enabled automatically if Groovy is on the classpath.

 
									
										@RunWith(SpringRunner.class)
									// ApplicationContext will be loaded from "/AppConfig.groovy" and
									// "/TestConfig.groovy" in the root of the classpath
									
										@ContextConfiguration({"/AppConfig.groovy", "/TestConfig.Groovy"})
									public
									classMyTest {
									// class body...}

If you omit both the locationsand valueattributes from the @ContextConfigurationannotation, the TestContext framework will attempt to detect a default Groovy script. Specifically, GenericGroovyXmlContextLoaderand GenericGroovyXmlWebContextLoaderdetect a default location based on the name of the test class. If your class is named com.example.MyTest, the Groovy context loader will load your application context from "classpath:com/example/MyTestContext.groovy".

									packagecom.example;
									
										@RunWith(SpringRunner.class)
									// ApplicationContext will be loaded from
									// "classpath:com/example/MyTestContext.groovy"
									
										@ContextConfiguration
									public
									classMyTest {
									// class body...}
[Tip] Declaring XML config and Groovy scripts simultaneously

Both XML configuration files and Groovy scripts can be declared simultaneously via the locationsor valueattribute of @ContextConfiguration. If the path to a configured resource location ends with .xmlit will be loaded using an XmlBeanDefinitionReader; otherwise it will be loaded using a GroovyBeanDefinitionReader.

The following listing demonstrates how to combine both in an integration test.

													
														@RunWith(SpringRunner.class)
													// ApplicationContext will be loaded from
													// "/app-config.xml" and "/TestConfig.groovy"
													
														@ContextConfiguration({ "/app-config.xml", "/TestConfig.groovy" })
													public
													classMyTest {
													// class body...}

Context configuration with annotated classes

To load an ApplicationContextfor your tests using annotated classes(see Section 7.12, “Java-based container configuration”), annotate your test class with @ContextConfigurationand configure the classesattribute with an array that contains references to annotated classes.

									
										@RunWith(SpringRunner.class)
									// ApplicationContext will be loaded from AppConfig and TestConfig
									
										@ContextConfiguration(classes = {AppConfig.class, TestConfig.class})
									public
									classMyTest {
									// class body...}
[Tip] Annotated Classes

The term annotated classcan refer to any of the following.

  • A class annotated with @Configuration
  • A component (i.e., a class annotated with @Component, @Service, @Repository, etc.)
  • A JSR-330 compliant class that is annotated with javax.injectannotations
  • Any other class that contains @Bean-methods

Consult the javadocs of @Configurationand @Beanfor further information regarding the configuration and semantics of annotated classes, paying special attention to the discussion of `@Bean` Lite Mode.

If you omit the classesattribute from the @ContextConfigurationannotation, the TestContext framework will attempt to detect the presence of default configuration classes. Specifically, AnnotationConfigContextLoaderand AnnotationConfigWebContextLoaderwill detect all staticnested classes of the test class that meet the requirements for configuration class implementations as specified in the @Configurationjavadocs. In the following example, the OrderServiceTestclass declares a staticnested configuration class named Configthat will be automatically used to load the ApplicationContextfor the test class. Note that the name of the configuration class is arbitrary. In addition, a test class can contain more than one staticnested configuration class if desired.

									
										@RunWith(SpringRunner.class)
									// ApplicationContext will be loaded from the
									// static nested Config class
									
										@ContextConfiguration
									public
									classOrderServiceTest {
									
										@Configuration
									static
									classConfig {
									// this bean will be injected into the OrderServiceTest class
									
										@Bean
									publicOrderService orderService() { OrderService orderService =
									newOrderServiceImpl();
									// set properties, etc.
									returnorderService; } }
									
										@Autowired
									privateOrderService orderService;
									
										@Test
									public
									voidtestOrderService() {
									// test the orderService} }

Mixing XML, Groovy scripts, and annotated classes

It may sometimes be desirable to mix XML configuration files, Groovy scripts, and annotated classes (i.e., typically @Configurationclasses) to configure an ApplicationContextfor your tests. For example, if you use XML configuration in production, you may decide that you want to use @Configurationclasses to configure specific Spring-managed components for your tests, or vice versa.

Furthermore, some third-party frameworks (like Spring Boot) provide first-class support for loading an ApplicationContextfrom different types of resources simultaneously (e.g., XML configuration files, Groovy scripts, and @Configurationclasses). The Spring Framework historically has not supported this for standard deployments. Consequently, most of the SmartContextLoaderimplementations that the Spring Framework delivers in the spring-testmodule support only one resource type per test context; however, this does not mean that you cannot use both. One exception to the general rule is that the GenericGroovyXmlContextLoaderand GenericGroovyXmlWebContextLoadersupport both XML configuration files and Groovy scripts simultaneously. Furthermore, third-party frameworks may choose to support the declaration of both locationsand classesvia @ContextConfiguration, and with the standard testing support in the TestContext framework, you have the following options.

If you want to use resource locations (e.g., XML or Groovy) and @Configurationclasses to configure your tests, you will have to pick one as the entry point, and that one will have to include or import the other. For example, in XML or Groovy scripts you can include @Configurationclasses via component scanning or define them as normal Spring beans; whereas, in a @Configurationclass you can use @ImportResourceto import XML configuration files or Groovy scripts. Note that this behavior is semantically equivalent to how you configure your application in production: in production configuration you will define either a set of XML or Groovy resource locations or a set of @Configurationclasses that your production ApplicationContextwill be loaded from, but you still have the freedom to include or import the other type of configuration.

Context configuration with context initializers

To configure an ApplicationContextfor your tests using context initializers, annotate your test class with @ContextConfigurationand configure the initializersattribute with an array that contains references to classes that implement ApplicationContextInitializer. The declared context initializers will then be used to initialize the ConfigurableApplicationContextthat is loaded for your tests. Note that the concrete ConfigurableApplicationContexttype supported by each declared initializer must be compatible with the type of ApplicationContextcreated by the SmartContextLoaderin use (i.e., typically a GenericApplicationContext). Furthermore, the order in which the initializers are invoked depends on whether they implement Spring’s Orderedinterface or are annotated with Spring’s @Orderannotation or the standard @Priorityannotation.

									
										@RunWith(SpringRunner.class)
									// ApplicationContext will be loaded from TestConfig
									// and initialized by TestAppCtxInitializer
									
										@ContextConfiguration( classes = TestConfig.class, initializers = TestAppCtxInitializer.class)
									public
									classMyTest {
									// class body...}

It is also possible to omit the declaration of XML configuration files, Groovy scripts, or annotated classes in @ContextConfigurationentirely and instead declare only ApplicationContextInitializerclasses which are then responsible for registering beans in the context — for example, by programmatically loading bean definitions from XML files or configuration classes.

									
										@RunWith(SpringRunner.class)
									// ApplicationContext will be initialized by EntireAppInitializer
									// which presumably registers beans in the context
									
										@ContextConfiguration(initializers = EntireAppInitializer.class)
									public
									classMyTest {
									// class body...}

Context configuration inheritance

@ContextConfigurationsupports boolean inheritLocationsand inheritInitializersattributes that denote whether resource locations or annotated classes and context initializers declared by superclasses should be inherited. The default value for both flags is true. This means that a test class inherits the resource locations or annotated classes as well as the context initializers declared by any superclasses. Specifically, the resource locations or annotated classes for a test class are appended to the list of resource locations or annotated classes declared by superclasses. Similarly, the initializers for a given test class will be added to the set of initializers defined by test superclasses. Thus, subclasses have the option of extendingthe resource locations, annotated classes, or context initializers.

If the inheritLocationsor inheritInitializersattribute in @ContextConfigurationis set to false, the resource locations or annotated classes and the context initializers, respectively, for the test class shadowand effectively replace the configuration defined by superclasses.

In the following example that uses XML resource locations, the ApplicationContextfor ExtendedTestwill be loaded from "base-config.xml" and "extended-config.xml", in that order. Beans defined in "extended-config.xml"may therefore override(i.e., replace) those defined in "base-config.xml".

									
										@RunWith(SpringRunner.class)
									// ApplicationContext will be loaded from "/base-config.xml"
									// in the root of the classpath
									
										@ContextConfiguration("/base-config.xml")
									public
									classBaseTest {
									// class body...}
									// ApplicationContext will be loaded from "/base-config.xml" and
									// "/extended-config.xml" in the root of the classpath
									
										@ContextConfiguration("/extended-config.xml")
									public
									classExtendedTest
									extendsBaseTest {
									// class body...}

Similarly, in the following example that uses annotated classes, the ApplicationContextfor ExtendedTestwill be loaded from the BaseConfig and ExtendedConfigclasses, in that order. Beans defined in ExtendedConfigmay therefore override (i.e., replace) those defined in BaseConfig.

									
										@RunWith(SpringRunner.class)
									// ApplicationContext will be loaded from BaseConfig
									
										@ContextConfiguration(classes = BaseConfig.class)
									public
									classBaseTest {
									// class body...}
									// ApplicationContext will be loaded from BaseConfig and ExtendedConfig
									
										@ContextConfiguration(classes = ExtendedConfig.class)
									public
									classExtendedTest
									extendsBaseTest {
									// class body...}

In the following example that uses context initializers, the ApplicationContextfor ExtendedTestwill be initialized using BaseInitializer and ExtendedInitializer. Note, however, that the order in which the initializers are invoked depends on whether they implement Spring’s Orderedinterface or are annotated with Spring’s @Orderannotation or the standard @Priorityannotation.

									
										@RunWith(SpringRunner.class)
									// ApplicationContext will be initialized by BaseInitializer
									
										@ContextConfiguration(initializers = BaseInitializer.class)
									public
									classBaseTest {
									// class body...}
									// ApplicationContext will be initialized by BaseInitializer
									// and ExtendedInitializer
									
										@ContextConfiguration(initializers = ExtendedInitializer.class)
									public
									classExtendedTest
									extendsBaseTest {
									// class body...}

Context configuration with environment profiles

Spring 3.1 introduced first-class support in the framework for the notion of environments and profiles (a.k.a., bean definition profiles), and integration tests can be configured to activate particular bean definition profiles for various testing scenarios. This is achieved by annotating a test class with the @ActiveProfilesannotation and supplying a list of profiles that should be activated when loading the ApplicationContextfor the test.

[Note] Note

@ActiveProfilesmay be used with any implementation of the new SmartContextLoaderSPI, but @ActiveProfilesis not supported with implementations of the older ContextLoaderSPI.

Let’s take a look at some examples with XML configuration and @Configurationclasses.

									<!-- app-config.xml -->
									<beans
									xmlns=
									"http://www.springframework.org/schema/beans"
									xmlns:xsi=
									"http://www.w3.org/2001/XMLSchema-instance"
									xmlns:jdbc=
									"http://www.springframework.org/schema/jdbc"
									xmlns:jee=
									"http://www.springframework.org/schema/jee"
									xsi:schemaLocation=
									"..."
									>
									<bean
									id=
									"transferService"
									class=
									"com.bank.service.internal.DefaultTransferService"
									>
									<constructor-arg
									ref=
									"accountRepository"
									/>
									<constructor-arg
									ref=
									"feePolicy"
									/>
									</bean>
									<bean
									id=
									"accountRepository"
									class=
									"com.bank.repository.internal.JdbcAccountRepository"
									>
									<constructor-arg
									ref=
									"dataSource"
									/>
									</bean>
									<bean
									id=
									"feePolicy"
									class=
									"com.bank.service.internal.ZeroFeePolicy"
									/>
									<beans
									profile=
									"dev"
									>
									<jdbc:embedded-database
									id=
									"dataSource"
									>
									<jdbc:script
									location=
									"classpath:com/bank/config/sql/schema.sql"
									/>
									<jdbc:script
									location=
									"classpath:com/bank/config/sql/test-data.sql"
									/>
									</jdbc:embedded-database>
									</beans>
									<beans
									profile=
									"production"
									>
									<jee:jndi-lookup
									id=
									"dataSource"
									jndi-name=
									"java:comp/env/jdbc/datasource"
									/>
									</beans>
									<beans
									profile=
									"default"
									>
									<jdbc:embedded-database
									id=
									"dataSource"
									>
									<jdbc:script
									location=
									"classpath:com/bank/config/sql/schema.sql"
									/>
									</jdbc:embedded-database>
									</beans>
									</beans>
									packagecom.bank.service;
									
										@RunWith(SpringRunner.class)
									// ApplicationContext will be loaded from "classpath:/app-config.xml"
									
										@ContextConfiguration("/app-config.xml")
									
										@ActiveProfiles("dev")
									public
									classTransferServiceTest {
									
										@Autowired
									privateTransferService transferService;
									
										@Test
									public
									voidtestTransferService() {
									// test the transferService} }

When TransferServiceTestis run, its ApplicationContextwill be loaded from the app-config.xmlconfiguration file in the root of the classpath. If you inspect app-config.xmlyou’ll notice that the accountRepositorybean has a dependency on a dataSourcebean; however, dataSourceis not defined as a top-level bean. Instead, dataSourceis defined three times: in the productionprofile, the devprofile, and the defaultprofile.

By annotating TransferServiceTestwith @ActiveProfiles("dev")we instruct the Spring TestContext Framework to load the ApplicationContextwith the active profiles set to {"dev"}. As a result, an embedded database will be created and populated with test data, and the accountRepositorybean will be wired with a reference to the development DataSource. And that’s likely what we want in an integration test.

It is sometimes useful to assign beans to a defaultprofile. Beans within the default profile are only included when no other profile is specifically activated. This can be used to define fallbackbeans to be used in the application’s default state. For example, you may explicitly provide a data source for devand productionprofiles, but define an in-memory data source as a default when neither of these is active.

The following code listings demonstrate how to implement the same configuration and integration test but using @Configurationclasses instead of XML.

									
										@Configuration
									
										@Profile("dev")
									public
									classStandaloneDataConfig {
									
										@Bean
									publicDataSource dataSource() {
									return
									newEmbeddedDatabaseBuilder() .setType(EmbeddedDatabaseType.HSQL) .addScript(
									"classpath:com/bank/config/sql/schema.sql") .addScript(
									"classpath:com/bank/config/sql/test-data.sql") .build(); } }
									
										@Configuration
									
										@Profile("production")
									public
									classJndiDataConfig {
									
										@Bean(destroyMethod="")
									publicDataSource dataSource()
									throwsException { Context ctx =
									newInitialContext();
									return(DataSource) ctx.lookup(
									"java:comp/env/jdbc/datasource"); } }
									
										@Configuration
									
										@Profile("default")
									public
									classDefaultDataConfig {
									
										@Bean
									publicDataSource dataSource() {
									return
									newEmbeddedDatabaseBuilder() .setType(EmbeddedDatabaseType.HSQL) .addScript(
									"classpath:com/bank/config/sql/schema.sql") .build(); } }
									
										@Configuration
									public
									classTransferServiceConfig {
									
										@AutowiredDataSource dataSource;
									
										@Bean
									publicTransferService transferService() {
									return
									newDefaultTransferService(accountRepository(), feePolicy()); }
									
										@Bean
									publicAccountRepository accountRepository() {
									return
									newJdbcAccountRepository(dataSource); }
									
										@Bean
									publicFeePolicy feePolicy() {
									return
									newZeroFeePolicy(); } }
									packagecom.bank.service;
									
										@RunWith(SpringRunner.class)
									
										@ContextConfiguration(classes = { TransferServiceConfig.class, StandaloneDataConfig.class, JndiDataConfig.class, DefaultDataConfig.class})
									
										@ActiveProfiles("dev")
									public
									classTransferServiceTest {
									
										@Autowired
									privateTransferService transferService;
									
										@Test
									public
									voidtestTransferService() {
									// test the transferService} }

In this variation, we have split the XML configuration into four independent @Configurationclasses:

  • TransferServiceConfig: acquires a dataSourcevia dependency injection using @Autowired
  • StandaloneDataConfig: defines a dataSourcefor an embedded database suitable for developer tests
  • JndiDataConfig: defines a dataSourcethat is retrieved from JNDI in a production environment
  • DefaultDataConfig: defines a dataSourcefor a default embedded database in case no profile is active

As with the XML-based configuration example, we still annotate TransferServiceTestwith @ActiveProfiles("dev"), but this time we specify all four configuration classes via the @ContextConfigurationannotation. The body of the test class itself remains completely unchanged.

It is often the case that a single set of profiles is used across multiple test classes within a given project. Thus, to avoid duplicate declarations of the @ActiveProfilesannotation it is possible to declare @ActiveProfilesonce on a base class, and subclasses will automatically inherit the @ActiveProfilesconfiguration from the base class. In the following example, the declaration of @ActiveProfiles(as well as other annotations) has been moved to an abstract superclass, AbstractIntegrationTest.

									packagecom.bank.service;
									
										@RunWith(SpringRunner.class)
									
										@ContextConfiguration(classes = { TransferServiceConfig.class, StandaloneDataConfig.class, JndiDataConfig.class, DefaultDataConfig.class})
									
										@ActiveProfiles("dev")
									public
									abstract
									classAbstractIntegrationTest { }
									packagecom.bank.service;
									// "dev" profile inherited from superclass
									public
									classTransferServiceTest
									extendsAbstractIntegrationTest {
									
										@Autowired
									privateTransferService transferService;
									
										@Test
									public
									voidtestTransferService() {
									// test the transferService} }

@ActiveProfilesalso supports an inheritProfilesattribute that can be used to disable the inheritance of active profiles.

									packagecom.bank.service;
									// "dev" profile overridden with "production"
									
										@ActiveProfiles(profiles = "production", inheritProfiles = false)
									public
									classProductionTransferServiceTest
									extendsAbstractIntegrationTest {
									// test body}

Furthermore, it is sometimes necessary to resolve active profiles for tests programmaticallyinstead of declaratively — for example, based on:

  • the current operating system
  • whether tests are being executed on a continuous integration build server
  • the presence of certain environment variables
  • the presence of custom class-level annotations
  • etc.

To resolve active bean definition profiles programmatically, simply implement a custom ActiveProfilesResolverand register it via the resolverattribute of @ActiveProfiles. The following example demonstrates how to implement and register a custom OperatingSystemActiveProfilesResolver. For further information, refer to the corresponding javadocs.

									packagecom.bank.service;
									// "dev" profile overridden programmatically via a custom resolver
									
										@ActiveProfiles( resolver = OperatingSystemActiveProfilesResolver.class, inheritProfiles = false)
									public
									classTransferServiceTest
									extendsAbstractIntegrationTest {
									// test body}
									packagecom.bank.service.test;
									public
									classOperatingSystemActiveProfilesResolver
									implementsActiveProfilesResolver {
									
										@OverrideString[] resolve(Class<?> testClass) { String profile = ...;
									// determine the value of profile based on the operating system
									return
									newString[] {profile}; } }

Context configuration with test property sources

Spring 3.1 introduced first-class support in the framework for the notion of an environment with a hierarchy of property sources, and since Spring 4.1 integration tests can be configured with test-specific property sources. In contrast to the @PropertySourceannotation used on @Configurationclasses, the @TestPropertySourceannotation can be declared on a test class to declare resource locations for test properties files or inlinedproperties. These test property sources will be added to the set of PropertySourcesin the Environmentfor the ApplicationContextloaded for the annotated integration test.

[Note] Note

@TestPropertySourcemay be used with any implementation of the SmartContextLoaderSPI, but @TestPropertySourceis not supported with implementations of the older ContextLoaderSPI.

Implementations of SmartContextLoadergain access to merged test property source values via the getPropertySourceLocations()and getPropertySourceProperties()methods in MergedContextConfiguration.

Declaring test property sources

Test properties files can be configured via the locationsor valueattribute of @TestPropertySourceas shown in the following example.

Both traditional and XML-based properties file formats are supported — for example, "classpath:/com/example/test.properties"or "file:///path/to/file.xml".

Each path will be interpreted as a Spring Resource. A plain path — for example, "test.properties" — will be treated as a classpath resource that is relativeto the package in which the test class is defined. A path starting with a slash will be treated as an absoluteclasspath resource, for example: "/org/example/test.xml". A path which references a URL (e.g., a path prefixed with classpath:, file:, http:, etc.) will be loaded using the specified resource protocol. Resource location wildcards (e.g. */.properties) are not permitted: each location must evaluate to exactly one .propertiesor .xmlresource.

									
										@ContextConfiguration
									
										@TestPropertySource("/test.properties")
									public
									classMyIntegrationTests {
									// class body...}

Inlinedproperties in the form of key-value pairs can be configured via the propertiesattribute of @TestPropertySourceas shown in the following example. All key-value pairs will be added to the enclosing Environmentas a single test PropertySourcewith the highest precedence.

The supported syntax for key-value pairs is the same as the syntax defined for entries in a Java properties file:

  • "key=value"
  • "key:value"
  • "key value"
									
										@ContextConfiguration
									
										@TestPropertySource(properties = {"timezone = GMT", "port: 4242"})
									public
									classMyIntegrationTests {
									// class body...}

Default properties file detection

If @TestPropertySourceis declared as an empty annotation (i.e., without explicit values for the locationsor propertiesattributes), an attempt will be made to detect a defaultproperties file relative to the class that declared the annotation. For example, if the annotated test class is com.example.MyTest, the corresponding default properties file is "classpath:com/example/MyTest.properties". If the default cannot be detected, an IllegalStateExceptionwill be thrown.

Precedence

Test property sources have higher precedence than those loaded from the operating system’s environment or Java system properties as well as property sources added by the application declaratively via @PropertySourceor programmatically. Thus, test property sources can be used to selectively override properties defined in system and application property sources. Furthermore, inlined properties have higher precedence than properties loaded from resource locations.

In the following example, the timezoneand portproperties as well as any properties defined in "/test.properties"will override any properties of the same name that are defined in system and application property sources. Furthermore, if the "/test.properties"file defines entries for the timezoneand portproperties those will be overridden by the inlinedproperties declared via the propertiesattribute.

									
										@ContextConfiguration
									
										@TestPropertySource( locations = "/test.properties", properties = {"timezone = GMT", "port: 4242"} )
									public
									classMyIntegrationTests {
									// class body...}

Inheriting and overriding test property sources

@TestPropertySourcesupports boolean inheritLocationsand inheritPropertiesattributes that denote whether resource locations for properties files and inlined properties declared by superclasses should be inherited. The default value for both flags is true. This means that a test class inherits the locations and inlined properties declared by any superclasses. Specifically, the locations and inlined properties for a test class are appended to the locations and inlined properties declared by superclasses. Thus, subclasses have the option of extendingthe locations and inlined properties. Note that properties that appear later will shadow(i.e.., override) properties of the same name that appear earlier. In addition, the aforementioned precedence rules apply for inherited test property sources as well.

If the inheritLocationsor inheritPropertiesattribute in @TestPropertySourceis set to false, the locations or inlined properties, respectively, for the test class shadowand effectively replace the configuration defined by superclasses.

In the following example, the ApplicationContextfor BaseTestwill be loaded using only the "base.properties"file as a test property source. In contrast, the ApplicationContextfor ExtendedTestwill be loaded using the "base.properties" and "extended.properties"files as test property source locations.

									
										@TestPropertySource("base.properties")
									
										@ContextConfiguration
									public
									classBaseTest {
									// ...}
									
										@TestPropertySource("extended.properties")
									
										@ContextConfiguration
									public
									classExtendedTest
									extendsBaseTest {
									// ...}

In the following example, the ApplicationContextfor BaseTestwill be loaded using only the inlined key1property. In contrast, the ApplicationContextfor ExtendedTestwill be loaded using the inlined key1and key2properties.

									
										@TestPropertySource(properties = "key1 = value1")
									
										@ContextConfiguration
									public
									classBaseTest {
									// ...}
									
										@TestPropertySource(properties = "key2 = value2")
									
										@ContextConfiguration
									public
									classExtendedTest
									extendsBaseTest {
									// ...}

Loading a WebApplicationContext

Spring 3.2 introduced support for loading a WebApplicationContextin integration tests. To instruct the TestContext framework to load a WebApplicationContextinstead of a standard ApplicationContext, simply annotate the respective test class with @WebAppConfiguration.

The presence of @WebAppConfigurationon your test class instructs the TestContext framework (TCF) that a WebApplicationContext(WAC) should be loaded for your integration tests. In the background the TCF makes sure that a MockServletContextis created and supplied to your test’s WAC. By default the base resource path for your MockServletContextwill be set to "src/main/webapp". This is interpreted as a path relative to the root of your JVM (i.e., normally the path to your project). If you’re familiar with the directory structure of a web application in a Maven project, you’ll know that "src/main/webapp"is the default location for the root of your WAR. If you need to override this default, simply provide an alternate path to the @WebAppConfigurationannotation (e.g., @WebAppConfiguration("src/test/webapp")). If you wish to reference a base resource path from the classpath instead of the file system, just use Spring’s classpath:prefix.

Please note that Spring’s testing support for WebApplicationContextsis on par with its support for standard ApplicationContexts. When testing with a WebApplicationContextyou are free to declare XML configuration files, Groovy scripts, or @Configurationclasses via @ContextConfiguration. You are of course also free to use any other test annotations such as @ActiveProfiles, @TestExecutionListeners, @Sql, @Rollback, etc.

The following examples demonstrate some of the various configuration options for loading a WebApplicationContext.

Conventions.  

									
										@RunWith(SpringRunner.class)
									// defaults to "file:src/main/webapp"
									
										@WebAppConfiguration
									// detects "WacTests-context.xml" in same package
									// or static nested @Configuration class
									
										@ContextConfiguration
									public
									classWacTests {
									//...}

The above example demonstrates the TestContext framework’s support for convention over configuration. If you annotate a test class with @WebAppConfigurationwithout specifying a resource base path, the resource path will effectively default to "file:src/main/webapp". Similarly, if you declare @ContextConfigurationwithout specifying resource locations, annotated classes, or context initializers, Spring will attempt to detect the presence of your configuration using conventions (i.e., "WacTests-context.xml"in the same package as the WacTestsclass or static nested @Configurationclasses).

Default resource semantics.  

									
										@RunWith(SpringRunner.class)
									// file system resource
									
										@WebAppConfiguration("webapp")
									// classpath resource
									
										@ContextConfiguration("/spring/test-servlet-config.xml")
									public
									classWacTests {
									//...}

This example demonstrates how to explicitly declare a resource base path with @WebAppConfigurationand an XML resource location with @ContextConfiguration. The important thing to note here is the different semantics for paths with these two annotations. By default, @WebAppConfigurationresource paths are file system based; whereas, @ContextConfigurationresource locations are classpath based.

Explicit resource semantics.  

									
										@RunWith(SpringRunner.class)
									// classpath resource
									
										@WebAppConfiguration("classpath:test-web-resources")
									// file system resource
									
										@ContextConfiguration("file:src/main/webapp/WEB-INF/servlet-config.xml")
									public
									classWacTests {
									//...}

In this third example, we see that we can override the default resource semantics for both annotations by specifying a Spring resource prefix. Contrast the comments in this example with the previous example.

To provide comprehensive web testing support, Spring 3.2 introduced a ServletTestExecutionListenerthat is enabled by default. When testing against a WebApplicationContextthis TestExecutionListenersets up default thread-local state via Spring Web’s RequestContextHolderbefore each test method and creates a MockHttpServletRequest, MockHttpServletResponse, and ServletWebRequestbased on the base resource path configured via @WebAppConfiguration. ServletTestExecutionListeneralso ensures that the MockHttpServletResponseand ServletWebRequestcan be injected into the test instance, and once the test is complete it cleans up thread-local state.

Once you have a WebApplicationContextloaded for your test you might find that you need to interact with the web mocks — for example, to set up your test fixture or to perform assertions after invoking your web component. The following example demonstrates which mocks can be autowired into your test instance. Note that the WebApplicationContextand MockServletContextare both cached across the test suite; whereas, the other mocks are managed per test method by the ServletTestExecutionListener.

Injecting mocks.  

									
										@WebAppConfiguration
									
										@ContextConfiguration
									public
									classWacTests {
									
										@AutowiredWebApplicationContext wac;
									// cached
									
										@AutowiredMockServletContext servletContext;
									// cached
									
										@AutowiredMockHttpSession session;
									
										@AutowiredMockHttpServletRequest request;
									
										@AutowiredMockHttpServletResponse response;
									
										@AutowiredServletWebRequest webRequest;
									//...}

Context caching

Once the TestContext framework loads an ApplicationContext(or WebApplicationContext) for a test, that context will be cached and reused for allsubsequent tests that declare the same unique context configuration within the same test suite. To understand how caching works, it is important to understand what is meant by uniqueand test suite.

An ApplicationContextcan be uniquelyidentified by the combination of configuration parameters that are used to load it. Consequently, the unique combination of configuration parameters are used to generate a keyunder which the context is cached. The TestContext framework uses the following configuration parameters to build the context cache key:

  • locations (from @ContextConfiguration)
  • classes (from @ContextConfiguration)
  • contextInitializerClasses (from @ContextConfiguration)
  • contextCustomizers (from ContextCustomizerFactory)
  • contextLoader (from @ContextConfiguration)
  • parent (from @ContextHierarchy)
  • activeProfiles (from @ActiveProfiles)
  • propertySourceLocations (from @TestPropertySource)
  • propertySourceProperties (from @TestPropertySource)
  • resourceBasePath (from @WebAppConfiguration)

For example, if TestClassAspecifies {"app-config.xml", "test-config.xml"}for the locations(or value) attribute of @ContextConfiguration, the TestContext framework will load the corresponding ApplicationContextand store it in a staticcontext cache under a key that is based solely on those locations. So if TestClassBalso defines {"app-config.xml", "test-config.xml"}for its locations (either explicitly or implicitly through inheritance) but does not define @WebAppConfiguration, a different ContextLoader, different active profiles, different context initializers, different test property sources, or a different parent context, then the same ApplicationContextwill be shared by both test classes. This means that the setup cost for loading an application context is incurred only once (per test suite), and subsequent test execution is much faster.

[Note] Test suites and forked processes

The Spring TestContext framework stores application contexts in a staticcache. This means that the context is literally stored in a staticvariable. In other words, if tests execute in separate processes the static cache will be cleared between each test execution, and this will effectively disable the caching mechanism.

To benefit from the caching mechanism, all tests must run within the same process or test suite. This can be achieved by executing all tests as a group within an IDE. Similarly, when executing tests with a build framework such as Ant, Maven, or Gradle it is important to make sure that the build framework does not forkbetween tests. For example, if the forkModefor the Maven Surefire plug-in is set to alwaysor pertest, the TestContext framework will not be able to cache application contexts between test classes and the build process will run significantly slower as a result.

Since Spring Framework 4.3, the size of the context cache is bounded with a default maximum size of 32. Whenever the maximum size is reached, a least recently used(LRU) eviction policy is used to evict and close stale contexts. The maximum size can be configured from the command line or a build script by setting a JVM system property named spring.test.context.cache.maxSize. As an alternative, the same property can be set programmatically via the SpringPropertiesAPI.

Since having a large number of application contexts loaded within a given test suite can cause the suite to take an unnecessarily long time to execute, it is often beneficial to know exactly how many contexts have been loaded and cached. To view the statistics for the underlying context cache, simply set the log level for the org.springframework.test.context.cachelogging category to DEBUG.

In the unlikely case that a test corrupts the application context and requires reloading — for example, by modifying a bean definition or the state of an application object — you can annotate your test class or test method with @DirtiesContext(see the discussion of @DirtiesContextin Section 15.4.1, “Spring Testing Annotations”). This instructs Spring to remove the context from the cache and rebuild the application context before executing the next test. Note that support for the @DirtiesContextannotation is provided by the DirtiesContextBeforeModesTestExecutionListenerand the DirtiesContextTestExecutionListenerwhich are enabled by default.

Context hierarchies

When writing integration tests that rely on a loaded Spring ApplicationContext, it is often sufficient to test against a single context; however, there are times when it is beneficial or even necessary to test against a hierarchy of ApplicationContexts. For example, if you are developing a Spring MVC web application you will typically have a root WebApplicationContextloaded via Spring’s ContextLoaderListenerand a child WebApplicationContextloaded via Spring’s DispatcherServlet. This results in a parent-child context hierarchy where shared components and infrastructure configuration are declared in the root context and consumed in the child context by web-specific components. Another use case can be found in Spring Batch applications where you often have a parent context that provides configuration for shared batch infrastructure and a child context for the configuration of a specific batch job.

Since Spring Framework 3.2.2, it is possible to write integration tests that use context hierarchies by declaring context configuration via the @ContextHierarchyannotation, either on an individual test class or within a test class hierarchy. If a context hierarchy is declared on multiple classes within a test class hierarchy it is also possible to merge or override the context configuration for a specific, named level in the context hierarchy. When merging configuration for a given level in the hierarchy the configuration resource type (i.e., XML configuration files or annotated classes) must be consistent; otherwise, it is perfectly acceptable to have different levels in a context hierarchy configured using different resource types.

The following JUnit 4 based examples demonstrate common configuration scenarios for integration tests that require the use of context hierarchies.

ControllerIntegrationTestsrepresents a typical integration testing scenario for a Spring MVC web application by declaring a context hierarchy consisting of two levels, one for the rootWebApplicationContext (loaded using the TestAppConfig @Configurationclass) and one for the dispatcher servlet WebApplicationContext(loaded using the WebConfig @Configurationclass). The WebApplicationContextthat is autowiredinto the test instance is the one for the child context (i.e., the lowest context in the hierarchy).

									
										@RunWith(SpringRunner.class)
									
										@WebAppConfiguration
									
										@ContextHierarchy({ @ContextConfiguration(classes = TestAppConfig.class), @ContextConfiguration(classes = WebConfig.class) })
									public
									classControllerIntegrationTests {
									
										@Autowired
									privateWebApplicationContext wac;
									// ...}

The following test classes define a context hierarchy within a test class hierarchy. AbstractWebTestsdeclares the configuration for a root WebApplicationContextin a Spring-powered web application. Note, however, that AbstractWebTestsdoes not declare @ContextHierarchy; consequently, subclasses of AbstractWebTestscan optionally participate in a context hierarchy or simply follow the standard semantics for @ContextConfiguration. SoapWebServiceTestsand RestWebServiceTestsboth extend AbstractWebTestsand define a context hierarchy via @ContextHierarchy. The result is that three application contexts will be loaded (one for each declaration of @ContextConfiguration), and the application context loaded based on the configuration in AbstractWebTestswill be set as the parent context for each of the contexts loaded for the concrete subclasses.

									
										@RunWith(SpringRunner.class)
									
										@WebAppConfiguration
									
										@ContextConfiguration("file:src/main/webapp/WEB-INF/applicationContext.xml")
									public
									abstract
									classAbstractWebTests {} @ContextHierarchy(
									
										@ContextConfiguration("/spring/soap-ws-config.xml")
									public
									classSoapWebServiceTests
									extendsAbstractWebTests {} @ContextHierarchy(
									
										@ContextConfiguration("/spring/rest-ws-config.xml")
									public
									classRestWebServiceTests
									extendsAbstractWebTests {}

The following classes demonstrate the use of namedhierarchy levels in order to mergethe configuration for specific levels in a context hierarchy. BaseTestsdefines two levels in the hierarchy, parentand child. ExtendedTestsextends BaseTestsand instructs the Spring TestContext Framework to merge the context configuration for the childhierarchy level, simply by ensuring that the names declared via the nameattribute in @ContextConfigurationare both "child". The result is that three application contexts will be loaded: one for "/app-config.xml", one for "/user-config.xml", and one for {"/user-config.xml", "/order-config.xml"}. As with the previous example, the application context loaded from "/app-config.xml"will be set as the parent context for the contexts loaded from "/user-config.xml"and {"/user-config.xml", "/order-config.xml"}.

									
										@RunWith(SpringRunner.class)
									
										@ContextHierarchy({ @ContextConfiguration(name = "parent", locations = "/app-config.xml"), @ContextConfiguration(name = "child", locations = "/user-config.xml") })
									public
									classBaseTests {}
									
										@ContextHierarchy( @ContextConfiguration(name = "child", locations = "/order-config.xml") )
									public
									classExtendedTests
									extendsBaseTests {}

In contrast to the previous example, this example demonstrates how to overridethe configuration for a given named level in a context hierarchy by setting the inheritLocationsflag in @ContextConfigurationto false. Consequently, the application context for ExtendedTestswill be loaded only from "/test-user-config.xml"and will have its parent set to the context loaded from "/app-config.xml".

									
										@RunWith(SpringRunner.class)
									
										@ContextHierarchy({ @ContextConfiguration(name = "parent", locations = "/app-config.xml"), @ContextConfiguration(name = "child", locations = "/user-config.xml") })
									public
									classBaseTests {}
									
										@ContextHierarchy( @ContextConfiguration( name = "child", locations = "/test-user-config.xml", inheritLocations = false ))
									public
									classExtendedTests
									extendsBaseTests {}
[Note] Dirtying a context within a context hierarchy

If @DirtiesContextis used in a test whose context is configured as part of a context hierarchy, the hierarchyModeflag can be used to control how the context cache is cleared. For further details consult the discussion of @DirtiesContextin Spring Testing Annotationsand the @DirtiesContextjavadocs.

15.5.5 Dependency injection of test fixtures

When you use the DependencyInjectionTestExecutionListener — which is configured by default — the dependencies of your test instances are injectedfrom beans in the application context that you configured with @ContextConfiguration. You may use setter injection, field injection, or both, depending on which annotations you choose and whether you place them on setter methods or fields. For consistency with the annotation support introduced in Spring 2.5 and 3.0, you can use Spring’s @Autowiredannotation or the @Injectannotation from JSR 330.

[Tip] Tip

The TestContext framework does not instrument the manner in which a test instance is instantiated. Thus the use of @Autowiredor @Injectfor constructors has no effect for test classes.

Because @Autowiredis used to perform autowiring by type , if you have multiple bean definitions of the same type, you cannot rely on this approach for those particular beans. In that case, you can use @Autowiredin conjunction with @Qualifier. As of Spring 3.0 you may also choose to use @Injectin conjunction with @Named. Alternatively, if your test class has access to its ApplicationContext, you can perform an explicit lookup by using (for example) a call to applicationContext.getBean("titleRepository").

If you do not want dependency injection applied to your test instances, simply do not annotate fields or setter methods with @Autowiredor @Inject. Alternatively, you can disable dependency injection altogether by explicitly configuring your class with @TestExecutionListenersand omitting DependencyInjectionTestExecutionListener.classfrom the list of listeners.

Consider the scenario of testing a HibernateTitleRepositoryclass, as outlined in the Goalssection. The next two code listings demonstrate the use of @Autowiredon fields and setter methods. The application context configuration is presented after all sample code listings.

[Note] Note

The dependency injection behavior in the following code listings is not specific to JUnit 4. The same DI techniques can be used in conjunction with any testing framework.

The following examples make calls to static assertion methods such as assertNotNull()but without prepending the call with Assert. In such cases, assume that the method was properly imported through an import staticdeclaration that is not shown in the example.

The first code listing shows a JUnit 4 based implementation of the test class that uses @Autowiredfor field injection.

								
									@RunWith(SpringRunner.class)
								// specifies the Spring configuration to load for this test fixture
								
									@ContextConfiguration("repository-config.xml")
								public
								classHibernateTitleRepositoryTests {
								// this instance will be dependency injected by type
								
									@Autowired
								privateHibernateTitleRepository titleRepository;
								
									@Test
								public
								voidfindById() { Title title = titleRepository.findById(
								newLong(
								10)); assertNotNull(title); } }

Alternatively, you can configure the class to use @Autowiredfor setter injection as seen below.

								
									@RunWith(SpringRunner.class)
								// specifies the Spring configuration to load for this test fixture
								
									@ContextConfiguration("repository-config.xml")
								public
								classHibernateTitleRepositoryTests {
								// this instance will be dependency injected by type
								privateHibernateTitleRepository titleRepository;
								
									@Autowired
								public
								voidsetTitleRepository(HibernateTitleRepository titleRepository) {
								this.titleRepository = titleRepository; }
								
									@Test
								public
								voidfindById() { Title title = titleRepository.findById(
								newLong(
								10)); assertNotNull(title); } }

The preceding code listings use the same XML context file referenced by the @ContextConfigurationannotation (that is, repository-config.xml), which looks like this:

								<?xml version="1.0" encoding="UTF-8"?>
								<beans
								xmlns=
								"http://www.springframework.org/schema/beans"
								xmlns:xsi=
								"http://www.w3.org/2001/XMLSchema-instance"
								xsi:schemaLocation=
								"http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd"
								>
								<!-- this bean will be injected into the HibernateTitleRepositoryTests class -->
								<bean
								id=
								"
								
									titleRepository" class="
								
									com.foo.repository.hibernate.HibernateTitleRepository">
								<property
								name=
								"sessionFactory"
								ref=
								"sessionFactory"
								/>
								</bean>
								<bean
								id=
								"sessionFactory"
								class=
								"org.springframework.orm.hibernate5.LocalSessionFactoryBean"
								>
								<!-- configuration elided for brevity -->
								</bean>
								</beans>
[Note] Note

If you are extending from a Spring-provided test base class that happens to use @Autowiredon one of its setter methods, you might have multiple beans of the affected type defined in your application context: for example, multiple DataSourcebeans. In such a case, you can override the setter method and use the @Qualifierannotation to indicate a specific target bean as follows, but make sure to delegate to the overridden method in the superclass as well.

												// ...
												
													@Autowired
												
													@Override
												public
												voidsetDataSource(
												
													@Qualifier("myDataSource")DataSource dataSource) {
												
													super.setDataSource(dataSource); }
												// ...

The specified qualifier value indicates the specific DataSourcebean to inject, narrowing the set of type matches to a specific bean. Its value is matched against <qualifier>declarations within the corresponding <bean>definitions. The bean name is used as a fallback qualifier value, so you may effectively also point to a specific bean by name there (as shown above, assuming that "myDataSource" is the bean id).

15.5.6 Testing request and session scoped beans

Request and session scoped beanshave been supported by Spring since the early years, and since Spring 3.2 it’s a breeze to test your request-scoped and session-scoped beans by following these steps.

  • Ensure that a WebApplicationContextis loaded for your test by annotating your test class with @WebAppConfiguration.
  • Inject the mock request or session into your test instance and prepare your test fixture as appropriate.
  • Invoke your web component that you retrieved from the configured WebApplicationContext(i.e., via dependency injection).
  • Perform assertions against the mocks.

The following code snippet displays the XML configuration for a login use case. Note that the userServicebean has a dependency on a request-scoped loginActionbean. Also, the LoginActionis instantiated using SpEL expressionsthat retrieve the username and password from the current HTTP request. In our test, we will want to configure these request parameters via the mock managed by the TestContext framework.

Request-scoped bean configuration.  

								<beans>
								<bean
								id=
								"userService"
								class=
								"com.example.SimpleUserService"
								c:loginAction-ref=
								"loginAction"
								/>
								<bean
								id=
								"loginAction"
								class=
								"com.example.LoginAction"
								c:username=
								"
								{request.getParameter('user')}" c:password="{request.getParameter('pswd')}" scope="request">
								<aop:scoped-proxy />
								</bean>
								</beans>

In RequestScopedBeanTestswe inject both the UserService(i.e., the subject under test) and the MockHttpServletRequestinto our test instance. Within our requestScope()test method we set up our test fixture by setting request parameters in the provided MockHttpServletRequest. When the loginUser()method is invoked on our userServicewe are assured that the user service has access to the request-scoped loginActionfor the current MockHttpServletRequest(i.e., the one we just set parameters in). We can then perform assertions against the results based on the known inputs for the username and password.

Request-scoped bean test.  

								
									@RunWith(SpringRunner.class)
								
									@ContextConfiguration
								
									@WebAppConfiguration
								public
								classRequestScopedBeanTests {
								
									@AutowiredUserService userService;
								
									@AutowiredMockHttpServletRequest request;
								
									@Test
								public
								voidrequestScope() { request.setParameter(
								"user",
								"enigma"); request.setParameter(
								"pswd",
								"$pr!ng"); LoginResults results = userService.loginUser();
								// assert results} }

The following code snippet is similar to the one we saw above for a request-scoped bean; however, this time the userServicebean has a dependency on a session-scoped userPreferencesbean. Note that the UserPreferencesbean is instantiated using a SpEL expression that retrieves the themefrom the current HTTP session. In our test, we will need to configure a theme in the mock session managed by the TestContext framework.

Session-scoped bean configuration.  

								<beans>
								<bean
								id=
								"userService"
								class=
								"com.example.SimpleUserService"
								c:userPreferences-ref=
								"userPreferences"
								/>
								<bean
								id=
								"userPreferences"
								class=
								"com.example.UserPreferences"
								c:theme=
								"#{session.getAttribute('theme')}"
								scope=
								"session"
								>
								<aop:scoped-proxy />
								</bean>
								</beans>

In SessionScopedBeanTestswe inject the UserServiceand the MockHttpSessioninto our test instance. Within our sessionScope()test method we set up our test fixture by setting the expected "theme" attribute in the provided MockHttpSession. When the processUserPreferences()method is invoked on our userServicewe are assured that the user service has access to the session-scoped userPreferencesfor the current MockHttpSession, and we can perform assertions against the results based on the configured theme.

Session-scoped bean test.  

								
									@RunWith(SpringRunner.class)
								
									@ContextConfiguration
								
									@WebAppConfiguration
								public
								classSessionScopedBeanTests {
								
									@AutowiredUserService userService;
								
									@AutowiredMockHttpSession session;
								
									@Test
								public
								voidsessionScope()
								throwsException { session.setAttribute(
								"theme",
								"blue"); Results results = userService.processUserPreferences();
								// assert results} }

15.5.7 Transaction management

In the TestContext framework, transactions are managed by the TransactionalTestExecutionListenerwhich is configured by default, even if you do not explicitly declare @TestExecutionListenerson your test class. To enable support for transactions, however, you must configure a PlatformTransactionManagerbean in the ApplicationContextthat is loaded via @ContextConfigurationsemantics (further details are provided below). In addition, you must declare Spring’s @Transactionalannotation either at the class or method level for your tests.

Test-managed transactions

Test-managed transactionsare transactions that are managed declarativelyvia the TransactionalTestExecutionListeneror programmaticallyvia TestTransaction(see below). Such transactions should not be confused with Spring-managed transactions(i.e., those managed directly by Spring within the ApplicationContextloaded for tests) or application-managed transactions(i.e., those managed programmatically within application code that is invoked via tests). Spring-managed and application-managed transactions will typically participate in test-managed transactions; however, caution should be taken if Spring-managed or application-managed transactions are configured with any propagationtype other than REQUIREDor SUPPORTS(see the discussion on transaction propagationfor details).

Enabling and disabling transactions

Annotating a test method with @Transactionalcauses the test to be run within a transaction that will, by default, be automatically rolled back after completion of the test. If a test class is annotated with @Transactional, each test method within that class hierarchy will be run within a transaction. Test methods that are not annotated with @Transactional(at the class or method level) will not be run within a transaction. Furthermore, tests that are annotated with @Transactionalbut have the propagationtype set to NOT_SUPPORTEDwill not be run within a transaction.

Note that AbstractTransactionalJUnit4SpringContextTestsand AbstractTransactionalTestNGSpringContextTestsare preconfigured for transactional support at the class level.

The following example demonstrates a common scenario for writing an integration test for a Hibernate-based UserRepository. As explained in the section called “Transaction rollback and commit behavior”, there is no need to clean up the database after the createUser()method is executed since any changes made to the database will be automatically rolled back by the TransactionalTestExecutionListener. See Section 15.7, “PetClinic Example”for an additional example.

									
										@RunWith(SpringRunner.class)
									
										@ContextConfiguration(classes = TestConfig.class)
									
										@Transactional
									public
									classHibernateUserRepositoryTests {
									
										@AutowiredHibernateUserRepository repository;
									
										@AutowiredSessionFactory sessionFactory; JdbcTemplate jdbcTemplate;
									
										@Autowired
									public
									voidsetDataSource(DataSource dataSource) {
									this.jdbcTemplate =
									newJdbcTemplate(dataSource); }
									
										@Test
									public
									voidcreateUser() {
									// track initial state in test database:
									final
									intcount = countRowsInTable(
									"user"); User user =
									newUser(...); repository.save(user);
									// Manual flush is required to avoid false positive in testsessionFactory.getCurrentSession().flush(); assertNumUsers(count +
									1); }
									protected
									intcountRowsInTable(String tableName) {
									returnJdbcTestUtils.countRowsInTable(
									this.jdbcTemplate, tableName); }
									protected
									voidassertNumUsers(
									intexpected) { assertEquals(
									"Number of rows in the [user] table.", expected, countRowsInTable(
									"user")); } }

Transaction rollback and commit behavior

By default, test transactions will be automatically rolled back after completion of the test; however, transactional commit and rollback behavior can be configured declaratively via the @Commitand @Rollbackannotations. See the corresponding entries in the annotation supportsection for further details.

Programmatic transaction management

Since Spring Framework 4.1, it is possible to interact with test-managed transactions programmaticallyvia the static methods in TestTransaction. For example, TestTransactionmay be used within testmethods, beforemethods, and aftermethods to start or end the current test-managed transaction or to configure the current test-managed transaction for rollback or commit. Support for TestTransactionis automatically available whenever the TransactionalTestExecutionListeneris enabled.

The following example demonstrates some of the features of TestTransaction. Consult the javadocs for TestTransactionfor further details.

									
										@ContextConfiguration(classes = TestConfig.class)
									public
									classProgrammaticTransactionManagementTests
									extendsAbstractTransactionalJUnit4SpringContextTests {
									
										@Test
									public
									voidtransactionalTest() {
									// assert initial state in test database:assertNumUsers(
									2); deleteFromTables(
									"user");
									// changes to the database will be committed!TestTransaction.flagForCommit(); TestTransaction.end(); assertFalse(TestTransaction.isActive()); assertNumUsers(
									0); TestTransaction.start();
									// perform other actions against the database that will
									// be automatically rolled back after the test completes...}
									protected
									voidassertNumUsers(
									intexpected) { assertEquals(
									"Number of rows in the [user] table.", expected, countRowsInTable(
									"user")); } }

Executing code outside of a transaction

Occasionally you need to execute certain code before or after a transactional test method but outside the transactional context — for example, to verify the initial database state prior to execution of your test or to verify expected transactional commit behavior after test execution (if the test was configured to commit the transaction). TransactionalTestExecutionListenersupports the @BeforeTransactionand @AfterTransactionannotations exactly for such scenarios. Simply annotate any voidmethod in a test class or any voiddefault method in a test interface with one of these annotations, and the TransactionalTestExecutionListenerensures that your before transaction methodor after transaction methodis executed at the appropriate time.

[Tip] Tip

Any before methods(such as methods annotated with JUnit 4’s @Before) and any after methods(such as methods annotated with JUnit 4’s @After) are executed withina transaction. In addition, methods annotated with @BeforeTransactionor @AfterTransactionare naturally not executed for test methods that are not configured to run within a transaction.

Configuring a transaction manager

TransactionalTestExecutionListenerexpects a PlatformTransactionManagerbean to be defined in the Spring ApplicationContextfor the test. In case there are multiple instances of PlatformTransactionManagerwithin the test’s ApplicationContext, a qualifiermay be declared via @Transactional("myTxMgr")or @Transactional(transactionManager = "myTxMgr"), or TransactionManagementConfigurercan be implemented by an @Configurationclass. Consult the javadocs for TestContextTransactionUtils.retrieveTransactionManager()for details on the algorithm used to look up a transaction manager in the test’s ApplicationContext.

Demonstration of all transaction-related annotations

The following JUnit 4 based example displays a fictitious integration testing scenario highlighting all transaction-related annotations. The example is notintended to demonstrate best practices but rather to demonstrate how these annotations can be used. Consult the annotation supportsection for further information and configuration examples. Transaction management for @Sqlcontains an additional example using @Sqlfor declarative SQL script execution with default transaction rollback semantics.

									
										@RunWith(SpringRunner.class)
									
										@ContextConfiguration
									
										@Transactional(transactionManager = "txMgr")
									
										@Commit
									public
									classFictitiousTransactionalTest {
									
										@BeforeTransaction
									voidverifyInitialDatabaseState() {
									// logic to verify the initial state before a transaction is started}
									
										@Before
									public
									voidsetUpTestDataWithinTransaction() {
									// set up test data within the transaction}
									
										@Test
									// overrides the class-level @Commit setting
									
										@Rollback
									public
									voidmodifyDatabaseWithinTransaction() {
									// logic which uses the test data and modifies database state}
									
										@After
									public
									voidtearDownWithinTransaction() {
									// execute "tear down" logic within the transaction}
									
										@AfterTransaction
									voidverifyFinalDatabaseState() {
									// logic to verify the final state after transaction has rolled back} }
[Note] Avoid false positives when testing ORM code

When you test application code that manipulates the state of a Hibernate session or JPA persistence context, make sure to flushthe underlying unit of work within test methods that execute that code. Failing to flush the underlying unit of work can produce false positives: your test may pass, but the same code throws an exception in a live, production environment. In the following Hibernate-based example test case, one method demonstrates a false positive, and the other method correctly exposes the results of flushing the session. Note that this applies to any ORM frameworks that maintain an in-memory unit of work.

													// ...
													
														@AutowiredSessionFactory sessionFactory;
													
														@Transactional
													
														@Test
													// no expected exception!
													public
													voidfalsePositive() { updateEntityInHibernateSession();
													// False positive: an exception will be thrown once the Hibernate
													// Session is finally flushed (i.e., in production code)}
													
														@Transactional
													
														@Test(expected = ...)
													public
													voidupdateWithSessionFlush() { updateEntityInHibernateSession();
													// Manual flush is required to avoid false positive in testsessionFactory.getCurrentSession().flush(); }
													// ...

Or for JPA:

													// ...
													
														@PersistenceContextEntityManager entityManager;
													
														@Transactional
													
														@Test
													// no expected exception!
													public
													voidfalsePositive() { updateEntityInJpaPersistenceContext();
													// False positive: an exception will be thrown once the JPA
													// EntityManager is finally flushed (i.e., in production code)}
													
														@Transactional
													
														@Test(expected = ...)
													public
													voidupdateWithEntityManagerFlush() { updateEntityInJpaPersistenceContext();
													// Manual flush is required to avoid false positive in testentityManager.flush(); }
													// ...

15.5.8 Executing SQL scripts

When writing integration tests against a relational database, it is often beneficial to execute SQL scripts to modify the database schema or insert test data into tables. The spring-jdbcmodule provides support for initializingan embedded or existing database by executing SQL scripts when the Spring ApplicationContextis loaded. See Section 19.8, “Embedded database support”and Section 19.8.5, “Testing data access logic with an embedded database”for details.

Although it is very useful to initialize a database for testing oncewhen the ApplicationContextis loaded, sometimes it is essential to be able to modify the database duringintegration tests. The following sections explain how to execute SQL scripts programmatically and declaratively during integration tests.

Executing SQL scripts programmatically

Spring provides the following options for executing SQL scripts programmatically within integration test methods.

  • org.springframework.jdbc.datasource.init.ScriptUtils
  • org.springframework.jdbc.datasource.init.ResourceDatabasePopulator
  • org.springframework.test.context.junit4.AbstractTransactionalJUnit4SpringContextTests
  • org.springframework.test.context.testng.AbstractTransactionalTestNGSpringContextTests

ScriptUtilsprovides a collection of static utility methods for working with SQL scripts and is mainly intended for internal use within the framework. However, if you require full control over how SQL scripts are parsed and executed, ScriptUtilsmay suit your needs better than some of the other alternatives described below. Consult the javadocs for individual methods in ScriptUtilsfor further details.

ResourceDatabasePopulatorprovides a simple object-based API for programmatically populating, initializing, or cleaning up a database using SQL scripts defined in external resources. ResourceDatabasePopulatorprovides options for configuring the character encoding, statement separator, comment delimiters, and error handling flags used when parsing and executing the scripts, and each of the configuration options has a reasonable default value. Consult the javadocs for details on default values. To execute the scripts configured in a ResourceDatabasePopulator, you can invoke either the populate(Connection)method to execute the populator against a java.sql.Connectionor the execute(DataSource)method to execute the populator against a javax.sql.DataSource. The following example specifies SQL scripts for a test schema and test data, sets the statement separator to "@@", and then executes the scripts against a DataSource.

									
										@Test
									public
									voiddatabaseTest { ResourceDatabasePopulator populator =
									newResourceDatabasePopulator(); populator.addScripts(
									newClassPathResource(
									"test-schema.sql"),
									newClassPathResource(
									"test-data.sql")); populator.setSeparator(
									"@@"); populator.execute(
									this.dataSource);
									// execute code that uses the test schema and data}

Note that ResourceDatabasePopulatorinternally delegates to ScriptUtilsfor parsing and executing SQL scripts. Similarly, the executeSqlScript(..)methods in AbstractTransactionalJUnit4SpringContextTestsand AbstractTransactionalTestNGSpringContextTestsinternally use a ResourceDatabasePopulatorfor executing SQL scripts. Consult the javadocs for the various executeSqlScript(..)methods for further details.

Executing SQL scripts declaratively with @Sql

In addition to the aforementioned mechanisms for executing SQL scripts programmatically, SQL scripts can also be configured declarativelyin the Spring TestContext Framework. Specifically, the @Sqlannotation can be declared on a test class or test method to configure the resource paths to SQL scripts that should be executed against a given database either before or after an integration test method. Note that method-level declarations override class-level declarations and that support for @Sqlis provided by the SqlScriptsTestExecutionListenerwhich is enabled by default.

Path resource semantics

Each path will be interpreted as a Spring Resource. A plain path — for example, "schema.sql" — will be treated as a classpath resource that is relativeto the package in which the test class is defined. A path starting with a slash will be treated as an absoluteclasspath resource, for example: "/org/example/schema.sql". A path which references a URL (e.g., a path prefixed with classpath:, file:, http:, etc.) will be loaded using the specified resource protocol.

The following example demonstrates how to use @Sqlat the class level and at the method level within a JUnit 4 based integration test class.

									
										@RunWith(SpringRunner.class)
									
										@ContextConfiguration
									
										@Sql("/test-schema.sql")
									public
									classDatabaseTests {
									
										@Test
									public
									voidemptySchemaTest {
									// execute code that uses the test schema without any test data}
									
										@Test
									
										@Sql({"/test-schema.sql", "/test-user-data.sql"})
									public
									voiduserTest {
									// execute code that uses the test schema and test data} }

Default script detection

If no SQL scripts are specified, an attempt will be made to detect a defaultscript depending on where @Sqlis declared. If a default cannot be detected, an IllegalStateExceptionwill be thrown.

  • class-level declaration: if the annotated test class is com.example.MyTest, the corresponding default script is "classpath:com/example/MyTest.sql".
  • method-level declaration: if the annotated test method is named testMethod()and is defined in the class com.example.MyTest, the corresponding default script is "classpath:com/example/MyTest.testMethod.sql".

Declaring multiple @Sqlsets

If multiple sets of SQL scripts need to be configured for a given test class or test method but with different syntax configuration, different error handling rules, or different execution phases per set, it is possible to declare multiple instances of @Sql. With Java 8, @Sqlcan be used as a repeatableannotation. Otherwise, the @SqlGroupannotation can be used as an explicit container for declaring multiple instances of @Sql.

The following example demonstrates the use of @Sqlas a repeatable annotation using Java 8. In this scenario the test-schema.sqlscript uses a different syntax for single-line comments.

									
										@Test
									
										@Sql(scripts = "/test-schema.sql", config = @SqlConfig(commentPrefix = "`"))
									
										@Sql("/test-user-data.sql")
									public
									voiduserTest {
									// execute code that uses the test schema and test data}

The following example is identical to the above except that the @Sqldeclarations are grouped together within @SqlGroupfor compatibility with Java 6 and Java 7.

									
										@Test
									
										@SqlGroup({ @Sql(scripts = "/test-schema.sql", config = @SqlConfig(commentPrefix = "`")), @Sql("/test-user-data.sql") )}
									public
									voiduserTest {
									// execute code that uses the test schema and test data}

Script execution phases

By default, SQL scripts will be executed beforethe corresponding test method. However, if a particular set of scripts needs to be executed afterthe test method — for example, to clean up database state — the executionPhaseattribute in @Sqlcan be used as seen in the following example. Note that ISOLATEDand AFTER_TEST_METHODare statically imported from Sql.TransactionModeand Sql.ExecutionPhaserespectively.

									
										@Test
									
										@Sql( scripts = "create-test-data.sql", config = @SqlConfig(transactionMode = ISOLATED) )
									
										@Sql( scripts = "delete-test-data.sql", config = @SqlConfig(transactionMode = ISOLATED), executionPhase = AFTER_TEST_METHOD )
									public
									voiduserTest {
									// execute code that needs the test data to be committed
									// to the database outside of the test's transaction}

Script configuration with @SqlConfig

Configuration for script parsing and error handling can be configured via the @SqlConfigannotation. When declared as a class-level annotation on an integration test class, @SqlConfigserves as globalconfiguration for all SQL scripts within the test class hierarchy. When declared directly via the configattribute of the @Sqlannotation, @SqlConfigserves as localconfiguration for the SQL scripts declared within the enclosing @Sqlannotation. Every attribute in @SqlConfighas an implicit default value which is documented in the javadocs of the corresponding attribute. Due to the rules defined for annotation attributes in the Java Language Specification, it is unfortunately not possible to assign a value of nullto an annotation attribute. Thus, in order to support overrides of inherited global configuration, @SqlConfigattributes have an explicit default value of either ""for Strings or DEFAULTfor Enums. This approach allows local declarations of @SqlConfigto selectively override individual attributes from global declarations of @SqlConfigby providing a value other than ""or DEFAULT. Global @SqlConfigattributes are inherited whenever local @SqlConfigattributes do not supply an explicit value other than ""or DEFAULT. Explicit localconfiguration therefore overrides globalconfiguration.

The configuration options provided by @Sqland @SqlConfigare equivalent to those supported by ScriptUtilsand ResourceDatabasePopulatorbut are a superset of those provided by the <jdbc:initialize-database/>XML namespace element. Consult the javadocs of individual attributes in @Sqland @SqlConfigfor details.

Transaction management for @Sql

By default, the SqlScriptsTestExecutionListenerwill infer the desired transaction semantics for scripts configured via @Sql. Specifically, SQL scripts will be executed without a transaction, within an existing Spring-managed transaction — for example, a transaction managed by the TransactionalTestExecutionListenerfor a test annotated with @Transactional — or within an isolated transaction, depending on the configured value of the transactionModeattribute in @SqlConfigand the presence of a PlatformTransactionManagerin the test’s ApplicationContext. As a bare minimum however, a javax.sql.DataSourcemust be present in the test’s ApplicationContext.

If the algorithms used by SqlScriptsTestExecutionListenerto detect a DataSourceand PlatformTransactionManagerand infer the transaction semantics do not suit your needs, you may specify explicit names via the dataSourceand transactionManagerattributes of @SqlConfig. Furthermore, the transaction propagation behavior can be controlled via the transactionModeattribute of @SqlConfig — for example, if scripts should be executed in an isolated transaction. Although a thorough discussion of all supported options for transaction management with @Sqlis beyond the scope of this reference manual, the javadocs for @SqlConfigand SqlScriptsTestExecutionListenerprovide detailed information, and the following example demonstrates a typical testing scenario using JUnit 4 and transactional tests with @Sql. Note that there is no need to clean up the database after the usersTest()method is executed since any changes made to the database (either within the test method or within the /test-data.sqlscript) will be automatically rolled back by the TransactionalTestExecutionListener(see transaction managementfor details).

									
										@RunWith(SpringRunner.class)
									
										@ContextConfiguration(classes = TestDatabaseConfig.class)
									
										@Transactional
									public
									classTransactionalSqlScriptsTests {
									protectedJdbcTemplate jdbcTemplate;
									
										@Autowired
									public
									voidsetDataSource(DataSource dataSource) {
									this.jdbcTemplate =
									newJdbcTemplate(dataSource); }
									
										@Test
									
										@Sql("/test-data.sql")
									public
									voidusersTest() {
									// verify state in test database:assertNumUsers(
									2);
									// execute code that uses the test data...}
									protected
									intcountRowsInTable(String tableName) {
									returnJdbcTestUtils.countRowsInTable(
									this.jdbcTemplate, tableName); }
									protected
									voidassertNumUsers(
									intexpected) { assertEquals(
									"Number of rows in the [user] table.", expected, countRowsInTable(
									"user")); } }

15.5.9 TestContext Framework support classes

Spring JUnit 4 Runner

The Spring TestContext Frameworkoffers full integration with JUnit 4 through a custom runner (supported on JUnit 4.12 or higher). By annotating test classes with @RunWith(SpringJUnit4ClassRunner.class)or the shorter @RunWith(SpringRunner.class)variant, developers can implement standard JUnit 4 based unit and integration tests and simultaneously reap the benefits of the TestContext framework such as support for loading application contexts, dependency injection of test instances, transactional test method execution, and so on. If you would like to use the Spring TestContext Framework with an alternative runner such as JUnit 4’s Parameterizedor third-party runners such as the MockitoJUnitRunner, you may optionally use Spring’s support for JUnit rulesinstead.

The following code listing displays the minimal requirements for configuring a test class to run with the custom Spring Runner. @TestExecutionListenersis configured with an empty list in order to disable the default listeners, which otherwise would require an ApplicationContextto be configured through @ContextConfiguration.

									
										@RunWith(SpringRunner.class)
									
										@TestExecutionListeners({})
									public
									classSimpleTest {
									
										@Test
									public
									voidtestMethod() {
									// execute test logic...} }

Spring JUnit 4 Rules

The org.springframework.test.context.junit4.rulespackage provides the following JUnit 4 rules (supported on JUnit 4.12 or higher).

  • SpringClassRule
  • SpringMethodRule

SpringClassRuleis a JUnit TestRulethat supports class-levelfeatures of the Spring TestContext Framework; whereas, SpringMethodRuleis a JUnit MethodRulethat supports instance-level and method-level features of the Spring TestContext Framework.

In contrast to the SpringRunner, Spring’s rule-based JUnit support has the advantage that it is independent of any org.junit.runner.Runnerimplementation and can therefore be combined with existing alternative runners like JUnit 4’s Parameterizedor third-party runners such as the MockitoJUnitRunner.

In order to support the full functionality of the TestContext framework, a SpringClassRulemust be combined with a SpringMethodRule. The following example demonstrates the proper way to declare these rules in an integration test.

									// Optionally specify a non-Spring Runner via @RunWith(...)
									
										@ContextConfiguration
									public
									classIntegrationTest {
									
										@ClassRule
									public
									static
									finalSpringClassRule SPRING_CLASS_RULE =
									newSpringClassRule();
									
										@Rule
									public
									finalSpringMethodRule springMethodRule =
									newSpringMethodRule();
									
										@Test
									public
									voidtestMethod() {
									// execute test logic...} }

JUnit 4 support classes

The org.springframework.test.context.junit4package provides the following support classes for JUnit 4 based test cases (supported on JUnit 4.12 or higher).

  • AbstractJUnit4SpringContextTests
  • AbstractTransactionalJUnit4SpringContextTests

AbstractJUnit4SpringContextTestsis an abstract base test class that integrates the Spring TestContext Frameworkwith explicit ApplicationContexttesting support in a JUnit 4 environment. When you extend AbstractJUnit4SpringContextTests, you can access a protected applicationContextinstance variable that can be used to perform explicit bean lookups or to test the state of the context as a whole.

AbstractTransactionalJUnit4SpringContextTestsis an abstract transactionalextension of AbstractJUnit4SpringContextTeststhat adds some convenience functionality for JDBC access. This class expects a javax.sql.DataSourcebean and a PlatformTransactionManagerbean to be defined in the ApplicationContext. When you extend AbstractTransactionalJUnit4SpringContextTestsyou can access a protected jdbcTemplateinstance variable that can be used to execute SQL statements to query the database. Such queries can be used to confirm database state both prior toand afterexecution of database-related application code, and Spring ensures that such queries run in the scope of the same transaction as the application code. When used in conjunction with an ORM tool, be sure to avoid false positives. As mentioned in Section 15.3, “JDBC Testing Support”, AbstractTransactionalJUnit4SpringContextTestsalso provides convenience methods which delegate to methods in JdbcTestUtilsusing the aforementioned jdbcTemplate. Furthermore, AbstractTransactionalJUnit4SpringContextTestsprovides an executeSqlScript(..)method for executing SQL scripts against the configured DataSource.

[Tip] Tip

These classes are a convenience for extension. If you do not want your test classes to be tied to a Spring-specific class hierarchy, you can configure your own custom test classes by using @RunWith(SpringRunner.class)or Spring’s JUnit rules.

TestNG support classes

The org.springframework.test.context.testngpackage provides the following support classes for TestNG based test cases.

  • AbstractTestNGSpringContextTests
  • AbstractTransactionalTestNGSpringContextTests

AbstractTestNGSpringContextTestsis an abstract base test class that integrates the Spring TestContext Frameworkwith explicit ApplicationContexttesting support in a TestNG environment. When you extend AbstractTestNGSpringContextTests, you can access a protected applicationContextinstance variable that can be used to perform explicit bean lookups or to test the state of the context as a whole.

AbstractTransactionalTestNGSpringContextTestsis an abstract transactionalextension of AbstractTestNGSpringContextTeststhat adds some convenience functionality for JDBC access. This class expects a javax.sql.DataSourcebean and a PlatformTransactionManagerbean to be defined in the ApplicationContext. When you extend AbstractTransactionalTestNGSpringContextTestsyou can access a protected jdbcTemplateinstance variable that can be used to execute SQL statements to query the database. Such queries can be used to confirm database state both prior toand afterexecution of database-related application code, and Spring ensures that such queries run in the scope of the same transaction as the application code. When used in conjunction with an ORM tool, be sure to avoid false positives. As mentioned in Section 15.3, “JDBC Testing Support”, AbstractTransactionalTestNGSpringContextTestsalso provides convenience methods which delegate to methods in JdbcTestUtilsusing the aforementioned jdbcTemplate. Furthermore, AbstractTransactionalTestNGSpringContextTestsprovides an executeSqlScript(..)method for executing SQL scripts against the configured DataSource.

[Tip] Tip

These classes are a convenience for extension. If you do not want your test classes to be tied to a Spring-specific class hierarchy, you can configure your own custom test classes by using @ContextConfiguration, @TestExecutionListeners, and so on, and by manually instrumenting your test class with a TestContextManager. See the source code of AbstractTestNGSpringContextTestsfor an example of how to instrument your test class.

15.6 Spring MVC Test Framework

The Spring MVC Test frameworkprovides first class support for testing Spring MVC code using a fluent API that can be used with JUnit, TestNG, or any other testing framework. It’s built on the Servlet API mock objectsfrom the spring-testmodule and hence does notuse a running Servlet container. It uses the DispatcherServletto provide full Spring MVC runtime behavior and provides support for loading actual Spring configuration with the TestContext frameworkin addition to a standalone mode in which controllers may be instantiated manually and tested one at a time.

Spring MVC Testalso provides client-side support for testing code that uses the RestTemplate. Client-side tests mock the server responses and also do notuse a running server.

[Tip] Tip

Spring Boot provides an option to write full, end-to-end integration tests that include a running server. If this is your goal please have a look at the Spring Boot reference page. For more information on the differences between out-of-container and end-to-end integration tests, see the section called “Differences between Out-of-Container and End-to-End Integration Tests”.

15.6.1 Server-Side Tests

It’s easy to write a plain unit test for a Spring MVC controller using JUnit or TestNG: simply instantiate the controller, inject it with mocked or stubbed dependencies, and call its methods passing MockHttpServletRequest, MockHttpServletResponse, etc., as necessary. However, when writing such a unit test, much remains untested: for example, request mappings, data binding, type conversion, validation, and much more. Furthermore, other controller methods such as @InitBinder, @ModelAttribute, and @ExceptionHandlermay also be invoked as part of the request processing lifecycle.

The goal of Spring MVC Testis to provide an effective way for testing controllers by performing requests and generating responses through the actual DispatcherServlet.

Spring MVC Testbuilds on the familiar "mock" implementations of the Servlet APIavailable in the spring-testmodule. This allows performing requests and generating responses without the need for running in a Servlet container. For the most part everything should work as it does at runtime with a few notable exceptions as explained in the section called “Differences between Out-of-Container and End-to-End Integration Tests”. Here is a JUnit 4 based example of using Spring MVC Test:

								import
								staticorg.springframework.test.web.servlet.request.MockMvcRequestBuilders.*;
								import
								staticorg.springframework.test.web.servlet.result.MockMvcResultMatchers.*;
								
									@RunWith(SpringRunner.class)
								
									@WebAppConfiguration
								
									@ContextConfiguration("test-servlet-context.xml")
								public
								classExampleTests {
								
									@Autowired
								privateWebApplicationContext wac;
								privateMockMvc mockMvc;
								
									@Before
								public
								voidsetup() {
								this.mockMvc = MockMvcBuilders.webAppContextSetup(
								this.wac).build(); }
								
									@Test
								public
								voidgetAccount()
								throwsException {
								this.mockMvc.perform(get(
								"/accounts/1").accept(MediaType.parseMediaType(
								"application/json;charset=UTF-8"))) .andExpect(status().isOk()) .andExpect(content().contentType(
								"application/json")) .andExpect(jsonPath(
								"$.name").value(
								"Lee")); } }

The above test relies on the WebApplicationContextsupport of the TestContext frameworkfor loading Spring configuration from an XML configuration file located in the same package as the test class, but Java-based and Groovy-based configuration are also supported. See these sample tests.

The MockMvcinstance is used to perform a GETrequest to "/accounts/1"and verify that the resulting response has status 200, the content type is "application/json", and the response body has a JSON property called "name" with the value "Lee". The jsonPathsyntax is supported through the Jayway JsonPath project. There are lots of other options for verifying the result of the performed request that will be discussed below.

Static Imports

The fluent API in the example above requires a few static imports such as MockMvcRequestBuilders.*, MockMvcResultMatchers.*, and MockMvcBuilders.*. An easy way to find these classes is to search for types matching "MockMvc*". If using Eclipse, be sure to add them as "favorite static members" in the Eclipse preferences under Java → Editor → Content Assist → Favorites. That will allow use of content assist after typing the first character of the static method name. Other IDEs (e.g. IntelliJ) may not require any additional configuration. Just check the support for code completion on static members.

Setup Options

There are two main options for creating an instance of MockMvc. The first is to load Spring MVC configuration through the TestContext framework, which loads the Spring configuration and injects a WebApplicationContextinto the test to use to build a MockMvcinstance:

									
										@RunWith(SpringRunner.class)
									
										@WebAppConfiguration
									
										@ContextConfiguration("my-servlet-context.xml")
									public
									classMyWebTests {
									
										@Autowired
									privateWebApplicationContext wac;
									privateMockMvc mockMvc;
									
										@Before
									public
									voidsetup() {
									this.mockMvc = MockMvcBuilders.webAppContextSetup(
									this.wac).build(); }
									// ...}

The second is to simply create a controller instance manually without loading Spring configuration. Instead basic default configuration, roughly comparable to that of the MVC JavaConfig or the MVC namespace, is automatically created and can be customized to a degree:

									public
									classMyWebTests {
									privateMockMvc mockMvc;
									
										@Before
									public
									voidsetup() {
									this.mockMvc = MockMvcBuilders.standaloneSetup(
									newAccountController()).build(); }
									// ...}

Which setup option should you use?

The "webAppContextSetup"loads your actual Spring MVC configuration resulting in a more complete integration test. Since the TestContext frameworkcaches the loaded Spring configuration, it helps keep tests running fast, even as you introduce more tests in your test suite. Furthermore, you can inject mock services into controllers through Spring configuration in order to remain focused on testing the web layer. Here is an example of declaring a mock service with Mockito:

									<bean
									id=
									"accountService"
									class=
									"org.mockito.Mockito"
									factory-method=
									"mock"
									>
									<constructor-arg
									value=
									"org.example.AccountService"
									/>
									</bean>

You can then inject the mock service into the test in order set up and verify expectations:

									
										@RunWith(SpringRunner.class)
									
										@WebAppConfiguration
									
										@ContextConfiguration("test-servlet-context.xml")
									public
									classAccountTests {
									
										@Autowired
									privateWebApplicationContext wac;
									privateMockMvc mockMvc;
									
										@Autowired
									privateAccountService accountService;
									// ...}

The "standaloneSetup"on the other hand is a little closer to a unit test. It tests one controller at a time: the controller can be injected with mock dependencies manually, and it doesn’t involve loading Spring configuration. Such tests are more focused on style and make it easier to see which controller is being tested, whether any specific Spring MVC configuration is required to work, and so on. The "standaloneSetup" is also a very convenient way to write ad-hoc tests to verify specific behavior or to debug an issue.

Just like with any "integration vs. unit testing" debate, there is no right or wrong answer. However, using the "standaloneSetup" does imply the need for additional "webAppContextSetup" tests in order to verify your Spring MVC configuration. Alternatively, you may choose to write all tests with "webAppContextSetup" in order to always test against your actual Spring MVC configuration.

Performing Requests

It’s easy to perform requests using any HTTP method:

mockMvc.perform(post(
									"/hotels/{id}",
									42).accept(MediaType.APPLICATION_JSON));

You can also perform file upload requests that internally use MockMultipartHttpServletRequestso that there is no actual parsing of a multipart request but rather you have to set it up:

mockMvc.perform(fileUpload(
									"/doc").file(
									"a1",
									"ABC".getBytes(
									"UTF-8")));

You can specify query parameters in URI template style:

mockMvc.perform(get(
									"/hotels?foo={foo}",
									"bar"));

Or you can add Servlet request parameters representing either query of form parameters:

mockMvc.perform(get(
									"/hotels").param(
									"foo",
									"bar"));

If application code relies on Servlet request parameters and doesn’t check the query string explicitly (as is most often the case) then it doesn’t matter which option you use. Keep in mind however that query params provided with the URI template will be decoded while request parameters provided through the param(…​)method are expected to already be decoded.

In most cases it’s preferable to leave out the context path and the Servlet path from the request URI. If you must test with the full request URI, be sure to set the contextPathand servletPathaccordingly so that request mappings will work:

mockMvc.perform(get(
									"/app/main/hotels/{id}").contextPath(
									"/app").servletPath(
									"/main"))

Looking at the above example, it would be cumbersome to set the contextPath and servletPath with every performed request. Instead you can set up default request properties:

									public
									classMyWebTests {
									privateMockMvc mockMvc;
									
										@Before
									public
									voidsetup() { mockMvc = standaloneSetup(
									newAccountController()) .defaultRequest(get(
									"/") .contextPath(
									"/app").servletPath(
									"/main") .accept(MediaType.APPLICATION_JSON).build(); }

The above properties will affect every request performed through the MockMvcinstance. If the same property is also specified on a given request, it overrides the default value. That is why the HTTP method and URI in the default request don’t matter since they must be specified on every request.

Defining Expectations

Expectations can be defined by appending one or more .andExpect(..)calls after performing a request:

mockMvc.perform(get(
									"/accounts/1")).andExpect(status().isOk());

MockMvcResultMatchers.*provides a number of expectations, some of which are further nested with more detailed expectations.

Expectations fall in two general categories. The first category of assertions verifies properties of the response: for example, the response status, headers, and content. These are the most important results to assert.

The second category of assertions goes beyond the response. These assertions allow one to inspect Spring MVC specific aspects such as which controller method processed the request, whether an exception was raised and handled, what the content of the model is, what view was selected, what flash attributes were added, and so on. They also allow one to inspect Servlet specific aspects such as request and session attributes.

The following test asserts that binding or validation failed:

mockMvc.perform(post(
									"/persons")) .andExpect(status().isOk()) .andExpect(model().attributeHasErrors(
									"person"));

Many times when writing tests, it’s useful to dumpthe results of the performed request. This can be done as follows, where print()is a static import from MockMvcResultHandlers:

mockMvc.perform(post(
									"/persons")) .andDo(print()) .andExpect(status().isOk()) .andExpect(model().attributeHasErrors(
									"person"));

As long as request processing does not cause an unhandled exception, the print()method will print all the available result data to System.out. Spring Framework 4.2 introduced a log()method and two additional variants of the print()method, one that accepts an OutputStreamand one that accepts a Writer. For example, invoking print(System.err)will print the result data to System.err; while invoking print(myWriter)will print the result data to a custom writer. If you would like to have the result data loggedinstead of printed, simply invoke the log()method which will log the result data as a single DEBUGmessage under the org.springframework.test.web.servlet.resultlogging category.

In some cases, you may want to get direct access to the result and verify something that cannot be verified otherwise. This can be achieved by appending .andReturn()after all other expectations:

MvcResult mvcResult = mockMvc.perform(post(
									"/persons")).andExpect(status().isOk()).andReturn();
									// ...

If all tests repeat the same expectations you can set up common expectations once when building the MockMvcinstance:

standaloneSetup(
									newSimpleController()) .alwaysExpect(status().isOk()) .alwaysExpect(content().contentType(
									"application/json;charset=UTF-8")) .build()

Note that common expectations are alwaysapplied and cannot be overridden without creating a separate MockMvcinstance.

When JSON response content contains hypermedia links created with Spring HATEOAS, the resulting links can be verified using JsonPath expressions:

mockMvc.perform(get(
									"/people").accept(MediaType.APPLICATION_JSON)) .andExpect(jsonPath(
									"$.links[?(@.rel == 'self')].href").value(
									"http://localhost:8080/people"));

When XML response content contains hypermedia links created with Spring HATEOAS, the resulting links can be verified using XPath expressions:

Map<String, String> ns = Collections.singletonMap(
									"ns",
									"http://www.w3.org/2005/Atom"); mockMvc.perform(get(
									"/handle").accept(MediaType.APPLICATION_XML)) .andExpect(xpath(
									"/person/ns:link[@rel='self']/@href", ns).string(
									"http://localhost:8080/people"));

Filter Registrations

When setting up a MockMvcinstance, you can register one or more Servlet Filterinstances:

mockMvc = standaloneSetup(
									newPersonController()).addFilters(
									newCharacterEncodingFilter()).build();

Registered filters will be invoked through via the MockFilterChainfrom spring-test, and the last filter will delegate to the DispatcherServlet.

Differences between Out-of-Container and End-to-End Integration Tests

As mentioned earlier Spring MVC Testis built on the Servlet API mock objects from the spring-testmodule and does not use a running Servlet container. Therefore there are some important differences compared to full end-to-end integration tests with an actual client and server running.

The easiest way to think about this is starting with a blank MockHttpServletRequest. Whatever you add to it is what the request will be. Things that may catch you by surprise are that there is no context path by default, no jsessionidcookie, no forwarding, error, or async dispatches, and therefore no actual JSP rendering. Instead, "forwarded" and "redirected" URLs are saved in the MockHttpServletResponseand can be asserted with expectations.

This means if you are using JSPs you can verify the JSP page to which the request was forwarded, but there won’t be any HTML rendered. In other words, the JSP will not be invoked. Note however that all other rendering technologies which don’t rely on forwarding such as Thymeleaf, Freemarker, and Velocity will render HTML to the response body as expected. The same is true for rendering JSON, XML, and other formats via @ResponseBodymethods.

Alternatively you may consider the full end-to-end integration testing support from Spring Boot via @WebIntegrationTest. See the Spring Boot reference.

There are pros and cons for each approach. The options provided in Spring MVC Testare different stops on the scale from classic unit testing to full integration testing. To be certain, none of the options in Spring MVC Test fall under the category of classic unit testing, but they area little closer to it. For example, you can isolate the web layer by injecting mocked services into controllers, in which case you’re testing the web layer only through the DispatcherServletbut with actual Spring configuration, just like you might test the data access layer in isolation from the layers above. Or you can use the standalone setup focusing on one controller at a time and manually providing the configuration required to make it work.

Another important distinction when using Spring MVC Testis that conceptually such tests are on the insideof the server-side so you can check what handler was used, if an exception was handled with a HandlerExceptionResolver, what the content of the model is, what binding errors there were, etc. That means it’s easier to write expectations since the server is not a black box as it is when testing it through an actual HTTP client. This is generally an advantage of classic unit testing, that it’s easier to write, reason about, and debug but does not replace the need for full integration tests. At the same time it’s important not to lose sight of the fact that the response is the most important thing to check. In short, there is room here for multiple styles and strategies of testing even within the same project.

Further Server-Side Test Examples

The framework’s own tests include many sample testsintended to demonstrate how to use Spring MVC Test. Browse these examples for further ideas. Also the spring-mvc-showcasehas full test coverage based on Spring MVC Test.

15.6.2 HtmlUnit Integration

Spring provides integration between MockMvcand HtmlUnit. This simplifies performing end-to-end testing when using HTML based views. This integration enables developers to:

  • Easily test HTML pages using tools such as HtmlUnit, WebDriver, & Gebwithout the need to deploy to a Servlet container
  • Test JavaScript within pages
  • Optionally test using mock services to speed up testing
  • Share logic between in-container end-to-end tests and out-of-container integration tests
[Note] Note

MockMvcworks with templating technologies that do not rely on a Servlet Container (e.g., Thymeleaf, Freemarker, Velocity, etc.), but it does not work with JSPs since they rely on the Servlet Container.

Why HtmlUnit Integration?

The most obvious question that comes to mind is, "Why do I need this?". The answer is best found by exploring a very basic sample application. Assume you have a Spring MVC web application that supports CRUD operations on a Messageobject. The application also supports paging through all messages. How would you go about testing it?

With Spring MVC Test, we can easily test if we are able to create a Message.

MockHttpServletRequestBuilder createMessage = post(
									"/messages/") .param(
									"summary",
									"Spring Rocks") .param(
									"text",
									"In case you didn't know, Spring Rocks!"); mockMvc.perform(createMessage) .andExpect(status().is3xxRedirection()) .andExpect(redirectedUrl(
									"/messages/123"));

What if we want to test our form view that allows us to create the message? For example, assume our form looks like the following snippet:

									<form
									id=
									"messageForm"
									action=
									"/messages/"
									method=
									"post"
									>
									<div
									class=
									"pull-right"
									>
									<a
									href=
									"/messages/"
									>Messages
									</a>
									</div>
									<label
									for=
									"summary"
									>Summary
									</label>
									<input
									type=
									"text"
									class=
									"required"
									id=
									"summary"
									name=
									"summary"
									value=
									""
									/>
									<label
									for=
									"text"
									>Message
									</label>
									<textarea
									id=
									"text"
									name=
									"text"
									>
									</textarea>
									<div
									class=
									"form-actions"
									>
									<input
									type=
									"submit"
									value=
									"Create"
									/>
									</div>
									</form>

How do we ensure that our form will produce the correct request to create a new message? A naive attempt would look like this:

mockMvc.perform(get(
									"/messages/form")) .andExpect(xpath(
									"//input[@name='summary']").exists()) .andExpect(xpath(
									"//textarea[@name='text']").exists());

This test has some obvious drawbacks. If we update our controller to use the parameter messageinstead of text, our form test would continue to pass even though the HTML form is out of synch with the controller. To resolve this we can combine our two tests.

String summaryParamName =
									"summary"; String textParamName =
									"text"; mockMvc.perform(get(
									"/messages/form")) .andExpect(xpath(
									"//input[@name='"+ summaryParamName +
									"']").exists()) .andExpect(xpath(
									"//textarea[@name='"+ textParamName +
									"']").exists()); MockHttpServletRequestBuilder createMessage = post(
									"/messages/") .param(summaryParamName,
									"Spring Rocks") .param(textParamName,
									"In case you didn't know, Spring Rocks!"); mockMvc.perform(createMessage) .andExpect(status().is3xxRedirection()) .andExpect(redirectedUrl(
									"/messages/123"));

This would reduce the risk of our test incorrectly passing, but there are still some problems.

  • What if we have multiple forms on our page? Admittedly we could update our xpath expressions, but they get more complicated the more factors we take into account (Are the fields the correct type? Are the fields enabled? etc.).
  • Another issue is that we are doing double the work we would expect. We must first verify the view, and then we submit the view with the same parameters we just verified. Ideally this could be done all at once.
  • Finally, there are some things that we still cannot account for. For example, what if the form has JavaScript validation that we wish to test as well?

The overall problem is that testing a web page does not involve a single interaction. Instead, it is a combination of how the user interacts with a web page and how that web page interacts with other resources. For example, the result of a form view is used as the input to a user for creating a message. In addition, our form view may potentially utilize additional resources which impact the behavior of the page, such as JavaScript validation.

Integration testing to the rescue?

To resolve the issues above we could perform end-to-end integration testing, but this has some obvious drawbacks. Consider testing the view that allows us to page through the messages. We might need the following tests.

  • Does our page display a notification to the user indicating that no results are available when the messages are empty?
  • Does our page properly display a single message?
  • Does our page properly support paging?

To set up these tests, we would need to ensure our database contained the proper messages in it. This leads to a number of additional challenges.

  • Ensuring the proper messages are in the database can be tedious; consider foreign key constraints.
  • Testing can become slow since each test would need to ensure that the database is in the correct state.
  • Since our database needs to be in a specific state, we cannot run tests in parallel.
  • Performing assertions on things like auto-generated ids, timestamps, etc. can be difficult.

These challenges do not mean that we should abandon end-to-end integration testing altogether. Instead, we can reduce the number of end-to-end integration tests by refactoring our detailed tests to use mock services which will execute much faster, more reliably, and without side effects. We can then implement a small number of trueend-to-end integration tests that validate simple workflows to ensure that everything works together properly.

Enter HtmlUnit Integration

So how can we achieve a balance between testing the interactions of our pages and still retain good performance within our test suite? The answer is: "By integrating MockMvc with HtmlUnit."

HtmlUnit Integration Options

There are a number of ways to integrate MockMvcwith HtmlUnit.

  • MockMvc and HtmlUnit: Use this option if you want to use the raw HtmlUnit libraries.
  • MockMvc and WebDriver: Use this option to ease development and reuse code between integration and end-to-end testing.
  • MockMvc and Geb: Use this option if you would like to use Groovy for testing, ease development, and reuse code between integration and end-to-end testing.

MockMvc and HtmlUnit

This section describes how to integrate MockMvcand HtmlUnit. Use this option if you want to use the raw HtmlUnit libraries.

MockMvc and HtmlUnit Setup

First, make sure that you have included a test dependency on net.sourceforge.htmlunit:htmlunit. In order to use HtmlUnit with Apache HttpComponents 4.5+, you will need to use HtmlUnit 2.18 or higher.

We can easily create an HtmlUnit WebClientthat integrates with MockMvcusing the MockMvcWebClientBuilderas follows.

										
											@AutowiredWebApplicationContext context; WebClient webClient;
										
											@Before
										public
										voidsetup() { webClient = MockMvcWebClientBuilder .webAppContextSetup(context) .build(); }
[Note] Note

This is a simple example of using MockMvcWebClientBuilder. For advanced usage see the section called “Advanced MockMvcWebClientBuilder”

This will ensure that any URL referencing localhostas the server will be directed to our MockMvcinstance without the need for a real HTTP connection. Any other URL will be requested using a network connection as normal. This allows us to easily test the use of CDNs.

MockMvc and HtmlUnit Usage

Now we can use HtmlUnit as we normally would, but without the need to deploy our application to a Servlet container. For example, we can request the view to create a message with the following.

HtmlPage createMsgFormPage = webClient.getPage(
										"http://localhost/messages/form");
[Note] Note

The default context path is "". Alternatively, we can specify the context path as illustrated in the section called “Advanced MockMvcWebClientBuilder”.

Once we have a reference to the HtmlPage, we can then fill out the form and submit it to create a message.

HtmlForm form = createMsgFormPage.getHtmlElementById(
										"messageForm"); HtmlTextInput summaryInput = createMsgFormPage.getHtmlElementById(
										"summary"); summaryInput.setValueAttribute(
										"Spring Rocks"); HtmlTextArea textInput = createMsgFormPage.getHtmlElementById(
										"text"); textInput.setText(
										"In case you didn't know, Spring Rocks!"); HtmlSubmitInput submit = form.getOneHtmlElementByAttribute(
										"input",
										"type",
										"submit"); HtmlPage newMessagePage = submit.click();

Finally, we can verify that a new message was created successfully. The following assertions use the AssertJlibrary.

assertThat(newMessagePage.getUrl().toString()).endsWith(
										"/messages/123"); String id = newMessagePage.getHtmlElementById(
										"id").getTextContent(); assertThat(id).isEqualTo(
										"123"); String summary = newMessagePage.getHtmlElementById(
										"summary").getTextContent(); assertThat(summary).isEqualTo(
										"Spring Rocks"); String text = newMessagePage.getHtmlElementById(
										"text").getTextContent(); assertThat(text).isEqualTo(
										"In case you didn't know, Spring Rocks!");

This improves on our MockMvc testin a number of ways. First we no longer have to explicitly verify our form and then create a request that looks like the form. Instead, we request the form, fill it out, and submit it, thereby significantly reducing the overhead.

Another important factor is that HtmlUnit uses the Mozilla Rhino engineto evaluate JavaScript. This means that we can test the behavior of JavaScript within our pages as well!

Refer to the HtmlUnit documentationfor additional information about using HtmlUnit.

Advanced MockMvcWebClientBuilder

In the examples so far, we have used MockMvcWebClientBuilderin the simplest way possible, by building a WebClientbased on the WebApplicationContextloaded for us by the Spring TestContext Framework. This approach is repeated here.

										
											@AutowiredWebApplicationContext context; WebClient webClient;
										
											@Before
										public
										voidsetup() { webClient = MockMvcWebClientBuilder .webAppContextSetup(context) .build(); }

We can also specify additional configuration options.

WebClient webClient;
										
											@Before
										public
										voidsetup() { webClient = MockMvcWebClientBuilder
										// demonstrates applying a MockMvcConfigurer (Spring Security).webAppContextSetup(context, springSecurity())
										// for illustration only - defaults to "".contextPath(
										"")
										// By default MockMvc is used for localhost only;
										// the following will use MockMvc for example.com and example.org as well.useMockMvcForHosts(
										"example.com",
										"example.org") .build(); }

As an alternative, we can perform the exact same setup by configuring the MockMvcinstance separately and supplying it to the MockMvcWebClientBuilderas follows.

MockMvc mockMvc = MockMvcBuilders .webAppContextSetup(context) .apply(springSecurity()) .build(); webClient = MockMvcWebClientBuilder .mockMvcSetup(mockMvc)
										// for illustration only - defaults to "".contextPath(
										"")
										// By default MockMvc is used for localhost only;
										// the following will use MockMvc for example.com and example.org as well.useMockMvcForHosts(
										"example.com",
										"example.org") .build();

This is more verbose, but by building the WebClientwith a MockMvcinstance we have the full power of MockMvcat our fingertips.

[Tip] Tip

For additional information on creating a MockMvcinstance refer to the section called “Setup Options”.

MockMvc and WebDriver

In the previous sections, we have seen how to use MockMvcin conjunction with the raw HtmlUnit APIs. In this section, we will leverage additional abstractions within the Selenium WebDriverto make things even easier.

Why WebDriver and MockMvc?

We can already use HtmlUnit and MockMvc, so why would we want to use WebDriver? The Selenium WebDriverprovides a very elegant API that allows us to easily organize our code. To better understand, let’s explore an example.

[Note] Note

Despite being a part of Selenium, WebDriver does not require a Selenium Server to run your tests.

Suppose we need to ensure that a message is created properly. The tests involve finding the HTML form input elements, filling them out, and making various assertions.

This approach results in numerous, separate tests because we want to test error conditions as well. For example, we want to ensure that we get an error if we fill out only part of the form. If we fill out the entire form, the newly created message should be displayed afterwards.

If one of the fields were named "summary", then we might have something like the following repeated in multiple places within our tests.

HtmlTextInput summaryInput = currentPage.getHtmlElementById(
										"summary"); summaryInput.setValueAttribute(summary);

So what happens if we change the idto "smmry"? Doing so would force us to update all of our tests to incorporate this change! Of course, this violates the DRY Principle; so we should ideally extract this code into its own method as follows.

										publicHtmlPage createMessage(HtmlPage currentPage, String summary, String text) { setSummary(currentPage, summary);
										// ...}
										public
										voidsetSummary(HtmlPage currentPage, String summary) { HtmlTextInput summaryInput = currentPage.getHtmlElementById(
										"summary"); summaryInput.setValueAttribute(summary); }

This ensures that we do not have to update all of our tests if we change the UI.

We might even take this a step further and place this logic within an Object that represents the HtmlPagewe are currently on.

										public
										classCreateMessagePage {
										finalHtmlPage currentPage;
										finalHtmlTextInput summaryInput;
										finalHtmlSubmitInput submit;
										publicCreateMessagePage(HtmlPage currentPage) {
										this.currentPage = currentPage;
										this.summaryInput = currentPage.getHtmlElementById(
										"summary");
										this.submit = currentPage.getHtmlElementById(
										"submit"); }
										public<T> T createMessage(String summary, String text)
										throwsException { setSummary(summary); HtmlPage result = submit.click();
										booleanerror = CreateMessagePage.at(result);
										return(T) (error ?
										newCreateMessagePage(result) :
										newViewMessagePage(result)); }
										public
										voidsetSummary(String summary)
										throwsException { summaryInput.setValueAttribute(summary); }
										public
										static
										booleanat(HtmlPage page) {
										return
										"Create Message".equals(page.getTitleText()); } }

Formerly, this pattern is known as the Page Object Pattern. While we can certainly do this with HtmlUnit, WebDriver provides some tools that we will explore in the following sections to make this pattern much easier to implement.

MockMvc and WebDriver Setup

To use Selenium WebDriver with the Spring MVC Test framework, make sure that your project includes a test dependency on org.seleniumhq.selenium:selenium-htmlunit-driver.

We can easily create a Selenium WebDriverthat integrates with MockMvcusing the MockMvcHtmlUnitDriverBuilderas follows.

										
											@AutowiredWebApplicationContext context; WebDriver driver;
										
											@Before
										public
										voidsetup() { driver = MockMvcHtmlUnitDriverBuilder .webAppContextSetup(context) .build(); }
[Note] Note

This is a simple example of using MockMvcHtmlUnitDriverBuilder. For more advanced usage, refer to the section called “Advanced MockMvcHtmlUnitDriverBuilder”

This will ensure that any URL referencing localhostas the server will be directed to our MockMvcinstance without the need for a real HTTP connection. Any other URL will be requested using a network connection as normal. This allows us to easily test the use of CDNs.

MockMvc and WebDriver Usage

Now we can use WebDriver as we normally would, but without the need to deploy our application to a Servlet container. For example, we can request the view to create a message with the following.

CreateMessagePage page = CreateMessagePage.to(driver);

We can then fill out the form and submit it to create a message.

ViewMessagePage viewMessagePage = page.createMessage(ViewMessagePage.
										class, expectedSummary, expectedText);

This improves on the design of our HtmlUnit testby leveraging the Page Object Pattern. As we mentioned in the section called “Why WebDriver and MockMvc?”, we can use the Page Object Pattern with HtmlUnit, but it is much easier with WebDriver. Let’s take a look at our new CreateMessagePageimplementation.

										public
										classCreateMessagePage
										extendsAbstractPage {
										
										
											1
										
										
											2
										privateWebElement summary;
										privateWebElement text;
										
										
											3
										
											@FindBy(css = "input[type=submit]")
										privateWebElement submit;
										publicCreateMessagePage(WebDriver driver) {
										super(driver); }
										public<T> T createMessage(Class<T> resultPage, String summary, String details) {
										this.summary.sendKeys(summary);
										this.text.sendKeys(details);
										this.submit.click();
										returnPageFactory.initElements(driver, resultPage); }
										public
										staticCreateMessagePage to(WebDriver driver) { driver.get(
										"http://localhost:9990/mail/messages/form");
										returnPageFactory.initElements(driver, CreateMessagePage.
										class); } }

1

The first thing you will notice is that CreateMessagePageextends the AbstractPage. We won’t go over the details of AbstractPage, but in summary it contains common functionality for all of our pages. For example, if our application has a navigational bar, global error messages, etc., this logic can be placed in a shared location.

2

The next thing you will notice is that we have a member variable for each of the parts of the HTML page that we are interested in. These are of type WebElement. WebDriver's PageFactoryallows us to remove a lot of code from the HtmlUnit version of CreateMessagePageby automatically resolving each WebElement. The PageFactory#initElements(WebDriver,Class<T>)method will automatically resolve each WebElementby using the field name and looking it up by the idor nameof the element within the HTML page.

3

We can use the @FindBy annotationto override the default lookup behavior. Our example demonstrates how to use the @FindByannotation to look up our submit button using a css selector, input[type=submit].

Finally, we can verify that a new message was created successfully. The following assertions use the FEST assertion library.

assertThat(viewMessagePage.getMessage()).isEqualTo(expectedMessage); assertThat(viewMessagePage.getSuccess()).isEqualTo(
										"Successfully created a new message");

We can see that our ViewMessagePageallows us to interact with our custom domain model. For example, it exposes a method that returns a Messageobject.

										publicMessage getMessage()
										throwsParseException { Message message =
										newMessage(); message.setId(getId()); message.setCreated(getCreated()); message.setSummary(getSummary()); message.setText(getText());
										returnmessage; }

We can then leverage the rich domain objects in our assertions.

Lastly, don’t forget to closethe WebDriverinstance when the test is complete.

										
											@After
										public
										voiddestroy() {
										if(driver != null) { driver.close(); } }

For additional information on using WebDriver, refer to the Selenium WebDriver documentation.

Advanced MockMvcHtmlUnitDriverBuilder

In the examples so far, we have used MockMvcHtmlUnitDriverBuilderin the simplest way possible, by building a WebDriverbased on the WebApplicationContextloaded for us by the Spring TestContext Framework. This approach is repeated here.

										
											@AutowiredWebApplicationContext context; WebDriver driver;
										
											@Before
										public
										voidsetup() { driver = MockMvcHtmlUnitDriverBuilder .webAppContextSetup(context) .build(); }

We can also specify additional configuration options.

WebDriver driver;
										
											@Before
										public
										voidsetup() { driver = MockMvcHtmlUnitDriverBuilder
										// demonstrates applying a MockMvcConfigurer (Spring Security).webAppContextSetup(context, springSecurity())
										// for illustration only - defaults to "".contextPath(
										"")
										// By default MockMvc is used for localhost only;
										// the following will use MockMvc for example.com and example.org as well.useMockMvcForHosts(
										"example.com",
										"example.org") .build(); }

As an alternative, we can perform the exact same setup by configuring the MockMvcinstance separately and supplying it to the MockMvcHtmlUnitDriverBuilderas follows.

MockMvc mockMvc = MockMvcBuilders .webAppContextSetup(context) .apply(springSecurity()) .build(); driver = MockMvcHtmlUnitDriverBuilder .mockMvcSetup(mockMvc)
										// for illustration only - defaults to "".contextPath(
										"")
										// By default MockMvc is used for localhost only;
										// the following will use MockMvc for example.com and example.org as well.useMockMvcForHosts(
										"example.com",
										"example.org") .build();

This is more verbose, but by building the WebDriverwith a MockMvcinstance we have the full power of MockMvcat our fingertips.

[Tip] Tip

For additional information on creating a MockMvcinstance refer to the section called “Setup Options”.

MockMvc and Geb

In the previous section, we saw how to use MockMvcwith WebDriver. In this section, we will use Gebto make our tests even Groovy-er.

Why Geb and MockMvc?

Geb is backed by WebDriver, so it offers many of the same benefitsthat we get from WebDriver. However, Geb makes things even easier by taking care of some of the boilerplate code for us.

MockMvc and Geb Setup

We can easily initialize a Geb Browserwith a Selenium WebDriverthat uses MockMvcas follows.

def setup() { browser.driver = MockMvcHtmlUnitDriverBuilder .webAppContextSetup(context) .build() }
[Note] Note

This is a simple example of using MockMvcHtmlUnitDriverBuilder. For more advanced usage, refer to the section called “Advanced MockMvcHtmlUnitDriverBuilder”

This will ensure that any URL referencing localhostas the server will be directed to our MockMvcinstance without the need for a real HTTP connection. Any other URL will be requested using a network connection as normal. This allows us to easily test the use of CDNs.

MockMvc and Geb Usage

Now we can use Geb as we normally would, but without the need to deploy our application to a Servlet container. For example, we can request the view to create a message with the following:

to CreateMessagePage

We can then fill out the form and submit it to create a message.

when: form.summary = expectedSummary form.text = expectedMessage submit.click(ViewMessagePage)

Any unrecognized method calls or property accesses/references that are not found will be forwarded to the current page object. This removes a lot of the boilerplate code we needed when using WebDriver directly.

As with direct WebDriver usage, this improves on the design of our HtmlUnit testby leveraging the Page Object Pattern. As mentioned previously, we can use the Page Object Pattern with HtmlUnit and WebDriver, but it is even easier with Geb. Let’s take a look at our new Groovy-based CreateMessagePageimplementation.

										classCreateMessagePage
										extendsPage {
										staticurl =
										'messages/form'
										staticat = { assert title ==
										'Messages : Create'; true }
										staticcontent = { submit { $(
										'input[type=submit]') } form { $(
										'form') } errors(required:false) { $(
										'label.error, .alert-error')?.text() } } }

The first thing you will notice is that our CreateMessagePageextends Page. We won’t go over the details of Page, but in summary it contains common functionality for all of our pages. The next thing you will notice is that we define a URL in which this page can be found. This allows us to navigate to the page as follows.

to CreateMessagePage

We also have an atclosure that determines if we are at the specified page. It should return trueif we are on the correct page. This is why we can assert that we are on the correct page as follows.

then: at CreateMessagePage errors.contains(
										'This field is required.')
[Note] Note

We use an assertion in the closure, so that we can determine where things went wrong if we were at the wrong page.

Next we create a contentclosure that specifies all the areas of interest within the page. We can use a jQuery-ish Navigator APIto select the content we are interested in.

Finally, we can verify that a new message was created successfully.

then: at ViewMessagePage success ==
										'Successfully created a new message'id date summary == expectedSummary message == expectedMessage

For further details on how to get the most out of Geb, consult The Book of Gebuser’s manual.

15.6.3 Client-Side REST Tests

Client-side tests can be used to test code that internally uses the RestTemplate. The idea is to declare expected requests and to provide "stub" responses so that you can focus on testing the code in isolation, i.e. without running a server. Here is an example:

RestTemplate restTemplate =
								newRestTemplate(); MockRestServiceServer mockServer = MockRestServiceServer.bindTo(restTemplate).build(); mockServer.expect(requestTo(
								"/greeting")).andRespond(withSuccess());
								// Test code that uses the above RestTemplate ...mockServer.verify();

In the above example, MockRestServiceServer, the central class for client-side REST tests, configures the RestTemplatewith a custom ClientHttpRequestFactorythat asserts actual requests against expectations and returns "stub" responses. In this case we expect a request to "/greeting" and want to return a 200 response with "text/plain" content. We could define as additional expected requests and stub responses as needed. When expected requests and stub responses are defined, the RestTemplatecan be used in client-side code as usual. At the end of testing mockServer.verify()can be used to verify that all expectations have been satisfied.

By default requests are expected in the order in which expectations were declared. You can set the ignoreExpectOrderoption when building the server in which case all expectations are checked (in order) to find a match for a given request. That means requests are allowed to come in any order. Here is an example:

server = MockRestServiceServer.bindTo(restTemplate).ignoreExpectOrder(true).build();

Even with unordered requests by default each request is allowed to execute once only. The expectmethod provides an overloaded variant that accepts an ExpectedCountargument that specifies a count range, e.g. once, manyTimes, max, min, between, and so on. Here is an example:

RestTemplate restTemplate =
								newRestTemplate(); MockRestServiceServer mockServer = MockRestServiceServer.bindTo(restTemplate).build(); mockServer.expect(times(
								2), requestTo(
								"/foo")).andRespond(withSuccess()); mockServer.expect(times(
								3), requestTo(
								"/bar")).andRespond(withSuccess());
								// ...mockServer.verify();

Note that when ignoreExpectOrderis not set (the default), and therefore requests are expected in order of declaration, then that order only applies to the first of any expected request. For example if "/foo" is expected 2 times followed by "/bar" 3 times, then there should be a request to "/foo" before there is a request to "/bar" but aside from that subsequent "/foo" and "/bar" requests can come at any time.

As an alternative to all of the above the client-side test support also provides a ClientHttpRequestFactoryimplementation that can be configured into a RestTemplateto bind it to a MockMvcinstance. That allows processing requests using actual server-side logic but without running a server. Here is an example:

MockMvc mockMvc = MockMvcBuilders.webAppContextSetup(
								this.wac).build();
								this.restTemplate =
								newRestTemplate(
								newMockMvcClientHttpRequestFactory(mockMvc));
								// Test code that uses the above RestTemplate ...mockServer.verify();

Static Imports

Just like with server-side tests, the fluent API for client-side tests requires a few static imports. Those are easy to find by searching "MockRest*". Eclipse users should add "MockRestRequestMatchers.*"and "MockRestResponseCreators.*"as "favorite static members" in the Eclipse preferences under Java → Editor → Content Assist → Favorites. That allows using content assist after typing the first character of the static method name. Other IDEs (e.g. IntelliJ) may not require any additional configuration. Just check the support for code completion on static members.

Further Examples of Client-side REST Tests

Spring MVC Test’s own tests include example testsof client-side REST tests.

15.7 PetClinic Example

The PetClinic application, available on GitHub, illustrates several features of the Spring TestContext Frameworkin a JUnit 4 environment. Most test functionality is included in the AbstractClinicTests, for which a partial listing is shown below:

							import
							staticorg.junit.Assert.assertEquals;
							// import ...
							
								@ContextConfiguration
							public
							abstract
							classAbstractClinicTests
							
								extends AbstractTransactionalJUnit4SpringContextTests{
							
								@Autowired
							protectedClinic clinic;
							
								@Test
							public
							voidgetVets() { Collection<Vet> vets =
							this.clinic.getVets(); assertEquals(
							"JDBC query must show the same number of vets",
							
								super.countRowsInTable("VETS"), vets.size()); Vet v1 = EntityUtils.getById(vets, Vet.
							class,
							2); assertEquals(
							"Leary", v1.getLastName()); assertEquals(
							1, v1.getNrOfSpecialties()); assertEquals(
							"radiology", (v1.getSpecialties().get(
							0)).getName());
							// ...}
							// ...}

Notes:

  • This test case extends the AbstractTransactionalJUnit4SpringContextTestsclass, from which it inherits configuration for Dependency Injection (through the DependencyInjectionTestExecutionListener) and transactional behavior (through the TransactionalTestExecutionListener).
  • The clinicinstance variable — the application object being tested — is set by Dependency Injection through @Autowiredsemantics.
  • The getVets()method illustrates how you can use the inherited countRowsInTable()method to easily verify the number of rows in a given table, thus verifying correct behavior of the application code being tested. This allows for stronger tests and lessens dependency on the exact test data. For example, you can add additional rows in the database without breaking tests.
  • Like many integration tests that use a database, most of the tests in AbstractClinicTestsdepend on a minimum amount of data already in the database before the test cases run. Alternatively, you might choose to populate the database within the test fixture set up of your test cases — again, within the same transaction as the tests.

The PetClinic application supports three data access technologies: JDBC, Hibernate, and JPA. By declaring @ContextConfigurationwithout any specific resource locations, the AbstractClinicTestsclass will have its application context loaded from the default location, AbstractClinicTests-context.xml, which declares a common DataSource. Subclasses specify additional context locations that must declare a PlatformTransactionManagerand a concrete implementation of Clinic.

For example, the Hibernate implementation of the PetClinic tests contains the following implementation. For this example, HibernateClinicTestsdoes not contain a single line of code: we only need to declare @ContextConfiguration, and the tests are inherited from AbstractClinicTests. Because @ContextConfigurationis declared without any specific resource locations, the Spring TestContext Frameworkloads an application context from all the beans defined in AbstractClinicTests-context.xml(i.e., the inherited locations) and HibernateClinicTests-context.xml, with HibernateClinicTests-context.xmlpossibly overriding beans defined in AbstractClinicTests-context.xml.

							
								@ContextConfiguration
							public
							classHibernateClinicTests
							extendsAbstractClinicTests { }

In a large-scale application, the Spring configuration is often split across multiple files. Consequently, configuration locations are typically specified in a common base class for all application-specific integration tests. Such a base class may also add useful instance variables — populated by Dependency Injection, naturally — such as a SessionFactoryin the case of an application using Hibernate.

As far as possible, you should have exactly the same Spring configuration files in your integration tests as in the deployed environment. One likely point of difference concerns database connection pooling and transaction infrastructure. If you are deploying to a full-blown application server, you will probably use its connection pool (available through JNDI) and JTA implementation. Thus in production you will use a JndiObjectFactoryBeanor <jee:jndi-lookup>for the DataSourceand JtaTransactionManager. JNDI and JTA will not be available in out-of-container integration tests, so you should use a combination like the Commons DBCP BasicDataSourceand DataSourceTransactionManageror HibernateTransactionManagerfor them. You can factor out this variant behavior into a single XML file, having the choice between application server and a 'local' configuration separated from all other configuration, which will not vary between the test and production environments. In addition, it is advisable to use properties files for connection settings. See the PetClinic application for an example.

16. Further Resources

Consult the following resources for more information about testing:

  • JUnit: " A programmer-oriented testing framework for Java". Used by the Spring Framework in its test suite.
  • TestNG: A testing framework inspired by JUnit with added support for annotations, test groups, data-driven testing, distributed testing, etc.
  • AssertJ: " Fluent assertions for Java" including support for Java 8 lambdas, streams, etc.
  • Mock Objects: Article in Wikipedia.
  • MockObjects.com: Web site dedicated to mock objects, a technique for improving the design of code within test-driven development.
  • Mockito: Java mock library based on the test spypattern.
  • EasyMock: Java library " that provides Mock Objects for interfaces (and objects through the class extension) by generating them on the fly using Java’s proxy mechanism." Used by the Spring Framework in its test suite.
  • JMock: Library that supports test-driven development of Java code with mock objects.
  • DbUnit: JUnit extension (also usable with Ant and Maven) targeted for database-driven projects that, among other things, puts your database into a known state between test runs.
  • The Grinder: Java load testing framework.

Part V. Data Access

This part of the reference documentation is concerned with data access and the interaction between the data access layer and the business or service layer.

Spring’s comprehensive transaction management support is covered in some detail, followed by thorough coverage of the various data access frameworks and technologies that the Spring Framework integrates with.

17. Transaction Management

17.1 Introduction to Spring Framework transaction management

Comprehensive transaction support is among the most compelling reasons to use the Spring Framework. The Spring Framework provides a consistent abstraction for transaction management that delivers the following benefits:

  • Consistent programming model across different transaction APIs such as Java Transaction API (JTA), JDBC, Hibernate, Java Persistence API (JPA), and Java Data Objects (JDO).
  • Support for declarative transaction management.
  • Simpler API for programmatictransaction management than complex transaction APIs such as JTA.
  • Excellent integration with Spring’s data access abstractions.

The following sections describe the Spring Framework’s transaction value-adds and technologies. (The chapter also includes discussions of best practices, application server integration, and solutions to common problems.)

17.2 Advantages of the Spring Framework’s transaction support model

Traditionally, Java EE developers have had two choices for transaction management: globalor localtransactions, both of which have profound limitations. Global and local transaction management is reviewed in the next two sections, followed by a discussion of how the Spring Framework’s transaction management support addresses the limitations of the global and local transaction models.

17.2.1 Global transactions

Global transactions enable you to work with multiple transactional resources, typically relational databases and message queues. The application server manages global transactions through the JTA, which is a cumbersome API to use (partly due to its exception model). Furthermore, a JTA UserTransactionnormally needs to be sourced from JNDI, meaning that you alsoneed to use JNDI in order to use JTA. Obviously the use of global transactions would limit any potential reuse of application code, as JTA is normally only available in an application server environment.

Previously, the preferred way to use global transactions was via EJB CMT( Container Managed Transaction): CMT is a form of declarative transaction management(as distinguished from programmatic transaction management). EJB CMT removes the need for transaction-related JNDI lookups, although of course the use of EJB itself necessitates the use of JNDI. It removes most but not all of the need to write Java code to control transactions. The significant downside is that CMT is tied to JTA and an application server environment. Also, it is only available if one chooses to implement business logic in EJBs, or at least behind a transactional EJB facade. The negatives of EJB in general are so great that this is not an attractive proposition, especially in the face of compelling alternatives for declarative transaction management.

17.2.2 Local transactions

Local transactions are resource-specific, such as a transaction associated with a JDBC connection. Local transactions may be easier to use, but have significant disadvantages: they cannot work across multiple transactional resources. For example, code that manages transactions using a JDBC connection cannot run within a global JTA transaction. Because the application server is not involved in transaction management, it cannot help ensure correctness across multiple resources. (It is worth noting that most applications use a single transaction resource.) Another downside is that local transactions are invasive to the programming model.

17.2.3 Spring Framework’s consistent programming model

Spring resolves the disadvantages of global and local transactions. It enables application developers to use a consistentprogramming model in any environment. You write your code once, and it can benefit from different transaction management strategies in different environments. The Spring Framework provides both declarative and programmatic transaction management. Most users prefer declarative transaction management, which is recommended in most cases.

With programmatic transaction management, developers work with the Spring Framework transaction abstraction, which can run over any underlying transaction infrastructure. With the preferred declarative model, developers typically write little or no code related to transaction management, and hence do not depend on the Spring Framework transaction API, or any other transaction API.

Do you need an application server for transaction management?

The Spring Framework’s transaction management support changes traditional rules as to when an enterprise Java application requires an application server.

In particular, you do not need an application server simply for declarative transactions through EJBs. In fact, even if your application server has powerful JTA capabilities, you may decide that the Spring Framework’s declarative transactions offer more power and a more productive programming model than EJB CMT.

Typically you need an application server’s JTA capability only if your application needs to handle transactions across multiple resources, which is not a requirement for many applications. Many high-end applications use a single, highly scalable database (such as Oracle RAC) instead. Standalone transaction managers such as Atomikos Transactionsand JOTMare other options. Of course, you may need other application server capabilities such as Java Message Service (JMS) and Java EE Connector Architecture (JCA).

The Spring Framework gives you the choice of when to scale your application to a fully loaded application server. Gone are the days when the only alternative to using EJB CMT or JTA was to write code with local transactions such as those on JDBC connections, and face a hefty rework if you need that code to run within global, container-managed transactions. With the Spring Framework, only some of the bean definitions in your configuration file, rather than your code, need to change.

17.3 Understanding the Spring Framework transaction abstraction

The key to the Spring transaction abstraction is the notion of a transaction strategy. A transaction strategy is defined by the org.springframework.transaction.PlatformTransactionManagerinterface:

							public
							interfacePlatformTransactionManager { TransactionStatus getTransaction( TransactionDefinition definition)
							throwsTransactionException;
							voidcommit(TransactionStatus status)
							throwsTransactionException;
							voidrollback(TransactionStatus status)
							throwsTransactionException; }

This is primarily a service provider interface (SPI), although it can be used programmaticallyfrom your application code. Because PlatformTransactionManageris an interface, it can be easily mocked or stubbed as necessary. It is not tied to a lookup strategy such as JNDI. PlatformTransactionManagerimplementations are defined like any other object (or bean) in the Spring Framework IoC container. This benefit alone makes Spring Framework transactions a worthwhile abstraction even when you work with JTA. Transactional code can be tested much more easily than if it used JTA directly.

Again in keeping with Spring’s philosophy, the TransactionExceptionthat can be thrown by any of the PlatformTransactionManagerinterface’s methods is unchecked(that is, it extends the java.lang.RuntimeExceptionclass). Transaction infrastructure failures are almost invariably fatal. In rare cases where application code can actually recover from a transaction failure, the application developer can still choose to catch and handle TransactionException. The salient point is that developers are not forcedto do so.

The getTransaction(..)method returns a TransactionStatusobject, depending on a TransactionDefinitionparameter. The returned TransactionStatusmight represent a new transaction, or can represent an existing transaction if a matching transaction exists in the current call stack. The implication in this latter case is that, as with Java EE transaction contexts, a TransactionStatusis associated with a threadof execution.

The TransactionDefinitioninterface specifies:

  • Isolation: The degree to which this transaction is isolated from the work of other transactions. For example, can this transaction see uncommitted writes from other transactions?
  • Propagation: Typically, all code executed within a transaction scope will run in that transaction. However, you have the option of specifying the behavior in the event that a transactional method is executed when a transaction context already exists. For example, code can continue running in the existing transaction (the common case); or the existing transaction can be suspended and a new transaction created. Spring offers all of the transaction propagation options familiar from EJB CMT. To read about the semantics of transaction propagation in Spring, see Section 17.5.7, “Transaction propagation”.
  • Timeout: How long this transaction runs before timing out and being rolled back automatically by the underlying transaction infrastructure.
  • Read-only status: A read-only transaction can be used when your code reads but does not modify data. Read-only transactions can be a useful optimization in some cases, such as when you are using Hibernate.

These settings reflect standard transactional concepts. If necessary, refer to resources that discuss transaction isolation levels and other core transaction concepts. Understanding these concepts is essential to using the Spring Framework or any transaction management solution.

The TransactionStatusinterface provides a simple way for transactional code to control transaction execution and query transaction status. The concepts should be familiar, as they are common to all transaction APIs:

							public
							interfaceTransactionStatus
							extendsSavepointManager {
							booleanisNewTransaction();
							booleanhasSavepoint();
							voidsetRollbackOnly();
							booleanisRollbackOnly();
							voidflush();
							booleanisCompleted(); }

Regardless of whether you opt for declarative or programmatic transaction management in Spring, defining the correct PlatformTransactionManagerimplementation is absolutely essential. You typically define this implementation through dependency injection.

PlatformTransactionManagerimplementations normally require knowledge of the environment in which they work: JDBC, JTA, Hibernate, and so on. The following examples show how you can define a local PlatformTransactionManagerimplementation. (This example works with plain JDBC.)

You define a JDBC DataSource

							<bean
							id=
							"dataSource"
							class=
							"org.apache.commons.dbcp.BasicDataSource"
							destroy-method=
							"close"
							>
							<property
							name=
							"driverClassName"
							value=
							"${jdbc.driverClassName}"
							/>
							<property
							name=
							"url"
							value=
							"${jdbc.url}"
							/>
							<property
							name=
							"username"
							value=
							"${jdbc.username}"
							/>
							<property
							name=
							"password"
							value=
							"${jdbc.password}"
							/>
							</bean>

The related PlatformTransactionManagerbean definition will then have a reference to the DataSourcedefinition. It will look like this:

							<bean
							id=
							"txManager"
							class=
							"org.springframework.jdbc.datasource.DataSourceTransactionManager"
							>
							<property
							name=
							"dataSource"
							ref=
							"dataSource"
							/>
							</bean>

If you use JTA in a Java EE container then you use a container DataSource, obtained through JNDI, in conjunction with Spring’s JtaTransactionManager. This is what the JTA and JNDI lookup version would look like:

							<?xml version="1.0" encoding="UTF-8"?>
							<beans
							xmlns=
							"http://www.springframework.org/schema/beans"
							xmlns:xsi=
							"http://www.w3.org/2001/XMLSchema-instance"
							xmlns:jee=
							"http://www.springframework.org/schema/jee"
							xsi:schemaLocation=
							" http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/jee http://www.springframework.org/schema/jee/spring-jee.xsd"
							>
							<jee:jndi-lookup
							id=
							"dataSource"
							jndi-name=
							"jdbc/jpetstore"
							/>
							<bean
							id=
							"txManager"
							class=
							"org.springframework.transaction.jta.JtaTransactionManager"
							/>
							<!-- other <bean/> definitions here -->
							</beans>

The JtaTransactionManagerdoes not need to know about the DataSource, or any other specific resources, because it uses the container’s global transaction management infrastructure.

[Note] Note

The above definition of the dataSourcebean uses the <jndi-lookup/>tag from the jeenamespace. For more information on schema-based configuration, see Chapter 41, XML Schema-based configuration , and for more information on the <jee/>tags see the section entitled Section 41.2.3, “the jee schema”.

You can also use Hibernate local transactions easily, as shown in the following examples. In this case, you need to define a Hibernate LocalSessionFactoryBean, which your application code will use to obtain Hibernate Sessioninstances.

The DataSourcebean definition will be similar to the local JDBC example shown previously and thus is not shown in the following example.

[Note] Note

If the DataSource, used by any non-JTA transaction manager, is looked up via JNDI and managed by a Java EE container, then it should be non-transactional because the Spring Framework, rather than the Java EE container, will manage the transactions.

The txManagerbean in this case is of the HibernateTransactionManagertype. In the same way as the DataSourceTransactionManagerneeds a reference to the DataSource, the HibernateTransactionManagerneeds a reference to the SessionFactory.

							<bean
							id=
							"sessionFactory"
							class=
							"org.springframework.orm.hibernate5.LocalSessionFactoryBean"
							>
							<property
							name=
							"dataSource"
							ref=
							"dataSource"
							/>
							<property
							name=
							"mappingResources"
							>
							<list>
							<value>org/springframework/samples/petclinic/hibernate/petclinic.hbm.xml
							</value>
							</list>
							</property>
							<property
							name=
							"hibernateProperties"
							>
							<value>hibernate.dialect=${hibernate.dialect}
							</value>
							</property>
							</bean>
							<bean
							id=
							"txManager"
							class=
							"org.springframework.orm.hibernate5.HibernateTransactionManager"
							>
							<property
							name=
							"sessionFactory"
							ref=
							"sessionFactory"
							/>
							</bean>

If you are using Hibernate and Java EE container-managed JTA transactions, then you should simply use the same JtaTransactionManageras in the previous JTA example for JDBC.

							<bean
							id=
							"txManager"
							class=
							"org.springframework.transaction.jta.JtaTransactionManager"
							/>
[Note] Note

If you use JTA , then your transaction manager definition will look the same regardless of what data access technology you use, be it JDBC, Hibernate JPA or any other supported technology. This is due to the fact that JTA transactions are global transactions, which can enlist any transactional resource.

In all these cases, application code does not need to change. You can change how transactions are managed merely by changing configuration, even if that change means moving from local to global transactions or vice versa.

17.4 Synchronizing resources with transactions

It should now be clear how you create different transaction managers, and how they are linked to related resources that need to be synchronized to transactions (for example DataSourceTransactionManagerto a JDBC DataSource, HibernateTransactionManagerto a Hibernate SessionFactory, and so forth). This section describes how the application code, directly or indirectly using a persistence API such as JDBC, Hibernate, or JDO, ensures that these resources are created, reused, and cleaned up properly. The section also discusses how transaction synchronization is triggered (optionally) through the relevant PlatformTransactionManager.

17.4.1 High-level synchronization approach

The preferred approach is to use Spring’s highest level template based persistence integration APIs or to use native ORM APIs with transaction- aware factory beans or proxies for managing the native resource factories. These transaction-aware solutions internally handle resource creation and reuse, cleanup, optional transaction synchronization of the resources, and exception mapping. Thus user data access code does not have to address these tasks, but can be focused purely on non-boilerplate persistence logic. Generally, you use the native ORM API or take a templateapproach for JDBC access by using the JdbcTemplate. These solutions are detailed in subsequent chapters of this reference documentation.

17.4.2 Low-level synchronization approach

Classes such as DataSourceUtils(for JDBC), EntityManagerFactoryUtils(for JPA), SessionFactoryUtils(for Hibernate), PersistenceManagerFactoryUtils(for JDO), and so on exist at a lower level. When you want the application code to deal directly with the resource types of the native persistence APIs, you use these classes to ensure that proper Spring Framework-managed instances are obtained, transactions are (optionally) synchronized, and exceptions that occur in the process are properly mapped to a consistent API.

For example, in the case of JDBC, instead of the traditional JDBC approach of calling the getConnection()method on the DataSource, you instead use Spring’s org.springframework.jdbc.datasource.DataSourceUtilsclass as follows:

Connection conn = DataSourceUtils.getConnection(dataSource);

If an existing transaction already has a connection synchronized (linked) to it, that instance is returned. Otherwise, the method call triggers the creation of a new connection, which is (optionally) synchronized to any existing transaction, and made available for subsequent reuse in that same transaction. As mentioned, any SQLExceptionis wrapped in a Spring Framework CannotGetJdbcConnectionException, one of the Spring Framework’s hierarchy of unchecked DataAccessExceptions. This approach gives you more information than can be obtained easily from the SQLException, and ensures portability across databases, even across different persistence technologies.

This approach also works without Spring transaction management (transaction synchronization is optional), so you can use it whether or not you are using Spring for transaction management.

Of course, once you have used Spring’s JDBC support, JPA support or Hibernate support, you will generally prefer not to use DataSourceUtilsor the other helper classes, because you will be much happier working through the Spring abstraction than directly with the relevant APIs. For example, if you use the Spring JdbcTemplateor jdbc.objectpackage to simplify your use of JDBC, correct connection retrieval occurs behind the scenes and you won’t need to write any special code.

17.4.3 TransactionAwareDataSourceProxy

At the very lowest level exists the TransactionAwareDataSourceProxyclass. This is a proxy for a target DataSource, which wraps the target DataSourceto add awareness of Spring-managed transactions. In this respect, it is similar to a transactional JNDI DataSourceas provided by a Java EE server.

It should almost never be necessary or desirable to use this class, except when existing code must be called and passed a standard JDBC DataSourceinterface implementation. In that case, it is possible that this code is usable, but participating in Spring managed transactions. It is preferable to write your new code by using the higher level abstractions mentioned above.

17.5 Declarative transaction management

[Note] Note

Most Spring Framework users choose declarative transaction management. This option has the least impact on application code, and hence is most consistent with the ideals of a non-invasivelightweight container.

The Spring Framework’s declarative transaction management is made possible with Spring aspect-oriented programming (AOP), although, as the transactional aspects code comes with the Spring Framework distribution and may be used in a boilerplate fashion, AOP concepts do not generally have to be understood to make effective use of this code.

The Spring Framework’s declarative transaction management is similar to EJB CMT in that you can specify transaction behavior (or lack of it) down to individual method level. It is possible to make a setRollbackOnly()call within a transaction context if necessary. The differences between the two types of transaction management are:

  • Unlike EJB CMT, which is tied to JTA, the Spring Framework’s declarative transaction management works in any environment. It can work with JTA transactions or local transactions using JDBC, JPA, Hibernate or JDO by simply adjusting the configuration files.
  • You can apply the Spring Framework declarative transaction management to any class, not merely special classes such as EJBs.
  • The Spring Framework offers declarative rollback rules,a feature with no EJB equivalent. Both programmatic and declarative support for rollback rules is provided.
  • The Spring Framework enables you to customize transactional behavior, by using AOP. For example, you can insert custom behavior in the case of transaction rollback. You can also add arbitrary advice, along with the transactional advice. With EJB CMT, you cannot influence the container’s transaction management except with setRollbackOnly().
  • The Spring Framework does not support propagation of transaction contexts across remote calls, as do high-end application servers. If you need this feature, we recommend that you use EJB. However, consider carefully before using such a feature, because normally, one does not want transactions to span remote calls.

Where is TransactionProxyFactoryBean?

Declarative transaction configuration in versions of Spring 2.0 and above differs considerably from previous versions of Spring. The main difference is that there is no longer any need to configure TransactionProxyFactoryBeanbeans.

The pre-Spring 2.0 configuration style is still 100% valid configuration; think of the new <tx:tags/>as simply defining TransactionProxyFactoryBeanbeans on your behalf.

The concept of rollback rules is important: they enable you to specify which exceptions (and throwables) should cause automatic rollback. You specify this declaratively, in configuration, not in Java code. So, although you can still call setRollbackOnly()on the TransactionStatusobject to roll back the current transaction back, most often you can specify a rule that MyApplicationExceptionmust always result in rollback. The significant advantage to this option is that business objects do not depend on the transaction infrastructure. For example, they typically do not need to import Spring transaction APIs or other Spring APIs.

Although EJB container default behavior automatically rolls back the transaction on a system exception(usually a runtime exception), EJB CMT does not roll back the transaction automatically on an application exception(that is, a checked exception other than java.rmi.RemoteException). While the Spring default behavior for declarative transaction management follows EJB convention (roll back is automatic only on unchecked exceptions), it is often useful to customize this behavior.

17.5.1 Understanding the Spring Framework’s declarative transaction implementation

It is not sufficient to tell you simply to annotate your classes with the @Transactionalannotation, add @EnableTransactionManagementto your configuration, and then expect you to understand how it all works. This section explains the inner workings of the Spring Framework’s declarative transaction infrastructure in the event of transaction-related issues.

The most important concepts to grasp with regard to the Spring Framework’s declarative transaction support are that this support is enabled via AOP proxies , and that the transactional advice is driven by metadata(currently XML- or annotation-based). The combination of AOP with transactional metadata yields an AOP proxy that uses a TransactionInterceptorin conjunction with an appropriate PlatformTransactionManagerimplementation to drive transactions around method invocations.

[Note] Note

Spring AOP is covered in Chapter 11, Aspect Oriented Programming with Spring .

Conceptually, calling a method on a transactional proxy looks like this…​

tx

17.5.2 Example of declarative transaction implementation

Consider the following interface, and its attendant implementation. This example uses Fooand Barclasses as placeholders so that you can concentrate on the transaction usage without focusing on a particular domain model. For the purposes of this example, the fact that the DefaultFooServiceclass throws UnsupportedOperationExceptioninstances in the body of each implemented method is good; it allows you to see transactions created and then rolled back in response to the UnsupportedOperationExceptioninstance.

								// the service interface that we want to make transactional
								packagex.y.service;
								public
								interfaceFooService { Foo getFoo(String fooName); Foo getFoo(String fooName, String barName);
								voidinsertFoo(Foo foo);
								voidupdateFoo(Foo foo); }
								// an implementation of the above interface
								packagex.y.service;
								public
								classDefaultFooService
								implementsFooService {
								publicFoo getFoo(String fooName) {
								throw
								newUnsupportedOperationException(); }
								publicFoo getFoo(String fooName, String barName) {
								throw
								newUnsupportedOperationException(); }
								public
								voidinsertFoo(Foo foo) {
								throw
								newUnsupportedOperationException(); }
								public
								voidupdateFoo(Foo foo) {
								throw
								newUnsupportedOperationException(); } }

Assume that the first two methods of the FooServiceinterface, getFoo(String)and getFoo(String, String), must execute in the context of a transaction with read-only semantics, and that the other methods, insertFoo(Foo)and updateFoo(Foo), must execute in the context of a transaction with read-write semantics. The following configuration is explained in detail in the next few paragraphs.

								<!-- from the file 'context.xml' -->
								<?xml version="1.0" encoding="UTF-8"?>
								<beans
								xmlns=
								"http://www.springframework.org/schema/beans"
								xmlns:xsi=
								"http://www.w3.org/2001/XMLSchema-instance"
								xmlns:aop=
								"http://www.springframework.org/schema/aop"
								xmlns:tx=
								"http://www.springframework.org/schema/tx"
								xsi:schemaLocation=
								" http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd"
								>
								<!-- this is the service object that we want to make transactional -->
								<bean
								id=
								"fooService"
								class=
								"x.y.service.DefaultFooService"
								/>
								<!-- the transactional advice (what 'happens'; see the <aop:advisor/> bean below) -->
								<tx:advice
								id=
								"txAdvice"
								transaction-manager=
								"txManager"
								>
								<!-- the transactional semantics... -->
								<tx:attributes>
								<!-- all methods starting with 'get' are read-only -->
								<tx:method
								name=
								"get*"
								read-only=
								"true"
								/>
								<!-- other methods use the default transaction settings (see below) -->
								<tx:method
								name=
								"*"
								/>
								</tx:attributes>
								</tx:advice>
								<!-- ensure that the above transactional advice runs for any execution of an operation defined by the FooService interface -->
								<aop:config>
								<aop:pointcut
								id=
								"fooServiceOperation"
								expression=
								"execution(* x.y.service.FooService.*(..))"
								/>
								<aop:advisor
								advice-ref=
								"txAdvice"
								pointcut-ref=
								"fooServiceOperation"
								/>
								</aop:config>
								<!-- don't forget the DataSource -->
								<bean
								id=
								"dataSource"
								class=
								"org.apache.commons.dbcp.BasicDataSource"
								destroy-method=
								"close"
								>
								<property
								name=
								"driverClassName"
								value=
								"oracle.jdbc.driver.OracleDriver"
								/>
								<property
								name=
								"url"
								value=
								"jdbc:oracle:thin:@rj-t42:1521:elvis"
								/>
								<property
								name=
								"username"
								value=
								"scott"
								/>
								<property
								name=
								"password"
								value=
								"tiger"
								/>
								</bean>
								<!-- similarly, don't forget the PlatformTransactionManager -->
								<bean
								id=
								"txManager"
								class=
								"org.springframework.jdbc.datasource.DataSourceTransactionManager"
								>
								<property
								name=
								"dataSource"
								ref=
								"dataSource"
								/>
								</bean>
								<!-- other <bean/> definitions here -->
								</beans>

Examine the preceding configuration. You want to make a service object, the fooServicebean, transactional. The transaction semantics to apply are encapsulated in the <tx:advice/>definition. The <tx:advice/>definition reads as " …​ all methods on starting with 'get'are to execute in the context of a read-only transaction, and all other methods are to execute with the default transaction semantics". The transaction-managerattribute of the <tx:advice/>tag is set to the name of the PlatformTransactionManagerbean that is going to drivethe transactions, in this case, the txManagerbean.

[Tip] Tip

You can omit the transaction-managerattribute in the transactional advice ( <tx:advice/>) if the bean name of the PlatformTransactionManagerthat you want to wire in has the name transactionManager. If the PlatformTransactionManagerbean that you want to wire in has any other name, then you must use the transaction-managerattribute explicitly, as in the preceding example.

The <aop:config/>definition ensures that the transactional advice defined by the txAdvicebean executes at the appropriate points in the program. First you define a pointcut that matches the execution of any operation defined in the FooServiceinterface ( fooServiceOperation). Then you associate the pointcut with the txAdviceusing an advisor. The result indicates that at the execution of a fooServiceOperation, the advice defined by txAdvicewill be run.

The expression defined within the <aop:pointcut/>element is an AspectJ pointcut expression; see Chapter 11, Aspect Oriented Programming with Spring for more details on pointcut expressions in Spring.

A common requirement is to make an entire service layer transactional. The best way to do this is simply to change the pointcut expression to match any operation in your service layer. For example:

								<aop:config>
								<aop:pointcut
								id=
								"fooServiceMethods"
								expression=
								"execution(* x.y.service.*.*(..))"
								/>
								<aop:advisor
								advice-ref=
								"txAdvice"
								pointcut-ref=
								"fooServiceMethods"
								/>
								</aop:config>
[Note] Note

In this example it is assumed that all your service interfaces are defined in the x.y.servicepackage; see Chapter 11, Aspect Oriented Programming with Spring for more details.

Now that we’ve analyzed the configuration, you may be asking yourself, " Okay…​ but what does all this configuration actually do?".

The above configuration will be used to create a transactional proxy around the object that is created from the fooServicebean definition. The proxy will be configured with the transactional advice, so that when an appropriate method is invoked on the proxy, a transaction is started, suspended, marked as read-only, and so on, depending on the transaction configuration associated with that method. Consider the following program that test drives the above configuration:

								public
								final
								classBoot {
								public
								static
								voidmain(
								finalString[] args)
								throwsException { ApplicationContext ctx =
								newClassPathXmlApplicationContext(
								"context.xml", Boot.
								class); FooService fooService = (FooService) ctx.getBean(
								"fooService"); fooService.insertFoo (
								newFoo()); } }

The output from running the preceding program will resemble the following. (The Log4J output and the stack trace from the UnsupportedOperationException thrown by the insertFoo(..) method of the DefaultFooService class have been truncated for clarity.)

								<!-- the Spring container is starting up... -->[AspectJInvocationContextExposingAdvisorAutoProxyCreator] - Creating implicit proxy for bean 'fooService' with 0 common interceptors and 1 specific interceptors
								<!-- the DefaultFooService is actually proxied -->[JdkDynamicAopProxy] - Creating JDK dynamic proxy for [x.y.service.DefaultFooService]
								<!-- ... the insertFoo(..) method is now being invoked on the proxy -->[TransactionInterceptor] - Getting transaction for x.y.service.FooService.insertFoo
								<!-- the transactional advice kicks in here... -->[DataSourceTransactionManager] - Creating new transaction with name [x.y.service.FooService.insertFoo] [DataSourceTransactionManager] - Acquired Connection [org.apache.commons.dbcp.PoolableConnection@a53de4] for JDBC transaction
								<!-- the insertFoo(..) method from DefaultFooService throws an exception... -->[RuleBasedTransactionAttribute] - Applying rules to determine whether transaction should rollback on java.lang.UnsupportedOperationException [TransactionInterceptor] - Invoking rollback for transaction on x.y.service.FooService.insertFoo due to throwable [java.lang.UnsupportedOperationException]
								<!-- and the transaction is rolled back (by default, RuntimeException instances cause rollback) -->[DataSourceTransactionManager] - Rolling back JDBC transaction on Connection [org.apache.commons.dbcp.PoolableConnection@a53de4] [DataSourceTransactionManager] - Releasing JDBC Connection after transaction [DataSourceUtils] - Returning JDBC Connection to DataSource Exception in thread "main" java.lang.UnsupportedOperationException at x.y.service.DefaultFooService.insertFoo(DefaultFooService.java:14)
								<!-- AOP infrastructure stack trace elements removed for clarity -->at $Proxy0.insertFoo(Unknown Source) at Boot.main(Boot.java:11)

17.5.3 Rolling back a declarative transaction

The previous section outlined the basics of how to specify transactional settings for classes, typically service layer classes, declaratively in your application. This section describes how you can control the rollback of transactions in a simple declarative fashion.

The recommended way to indicate to the Spring Framework’s transaction infrastructure that a transaction’s work is to be rolled back is to throw an Exceptionfrom code that is currently executing in the context of a transaction. The Spring Framework’s transaction infrastructure code will catch any unhandled Exceptionas it bubbles up the call stack, and make a determination whether to mark the transaction for rollback.

In its default configuration, the Spring Framework’s transaction infrastructure code onlymarks a transaction for rollback in the case of runtime, unchecked exceptions; that is, when the thrown exception is an instance or subclass of RuntimeException. ( Errors will also - by default - result in a rollback). Checked exceptions that are thrown from a transactional method do notresult in rollback in the default configuration.

You can configure exactly which Exceptiontypes mark a transaction for rollback, including checked exceptions. The following XML snippet demonstrates how you configure rollback for a checked, application-specific Exceptiontype.

								<tx:advice
								id=
								"txAdvice"
								transaction-manager=
								"txManager"
								>
								<tx:attributes>
								<tx:method
								name=
								"get*"
								read-only=
								"true"
								rollback-for=
								"NoProductInStockException"
								/>
								<tx:method
								name=
								"*"
								/>
								</tx:attributes>
								</tx:advice>

You can also specify 'no rollback rules', if you do notwant a transaction rolled back when an exception is thrown. The following example tells the Spring Framework’s transaction infrastructure to commit the attendant transaction even in the face of an unhandled InstrumentNotFoundException.

								<tx:advice
								id=
								"txAdvice"
								>
								<tx:attributes>
								<tx:method
								name=
								"updateStock"
								no-rollback-for=
								"InstrumentNotFoundException"
								/>
								<tx:method
								name=
								"*"
								/>
								</tx:attributes>
								</tx:advice>

When the Spring Framework’s transaction infrastructure catches an exception and is consults configured rollback rules to determine whether to mark the transaction for rollback, the strongestmatching rule wins. So in the case of the following configuration, any exception other than an InstrumentNotFoundExceptionresults in a rollback of the attendant transaction.

								<tx:advice
								id=
								"txAdvice"
								>
								<tx:attributes>
								<tx:method
								name=
								"*"
								rollback-for=
								"Throwable"
								no-rollback-for=
								"InstrumentNotFoundException"
								/>
								</tx:attributes>
								</tx:advice>

You can also indicate a required rollback programmatically. Although very simple, this process is quite invasive, and tightly couples your code to the Spring Framework’s transaction infrastructure:

								public
								voidresolvePosition() {
								try{
								// some business logic...}
								catch(NoProductInStockException ex) {
								// trigger rollback programmaticallyTransactionAspectSupport.currentTransactionStatus().setRollbackOnly(); } }

You are strongly encouraged to use the declarative approach to rollback if at all possible. Programmatic rollback is available should you absolutely need it, but its usage flies in the face of achieving a clean POJO-based architecture.

17.5.4 Configuring different transactional semantics for different beans

Consider the scenario where you have a number of service layer objects, and you want to apply a totally differenttransactional configuration to each of them. You do this by defining distinct <aop:advisor/>elements with differing pointcutand advice-refattribute values.

As a point of comparison, first assume that all of your service layer classes are defined in a root x.y.servicepackage. To make all beans that are instances of classes defined in that package (or in subpackages) and that have names ending in Servicehave the default transactional configuration, you would write the following:

								<?xml version="1.0" encoding="UTF-8"?>
								<beans
								xmlns=
								"http://www.springframework.org/schema/beans"
								xmlns:xsi=
								"http://www.w3.org/2001/XMLSchema-instance"
								xmlns:aop=
								"http://www.springframework.org/schema/aop"
								xmlns:tx=
								"http://www.springframework.org/schema/tx"
								xsi:schemaLocation=
								" http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd"
								>
								<aop:config>
								<aop:pointcut
								id=
								"serviceOperation"
								expression=
								"execution(* x.y.service..*Service.*(..))"
								/>
								<aop:advisor
								pointcut-ref=
								"serviceOperation"
								advice-ref=
								"txAdvice"
								/>
								</aop:config>
								<!-- these two beans will be transactional... -->
								<bean
								id=
								"fooService"
								class=
								"x.y.service.DefaultFooService"
								/>
								<bean
								id=
								"barService"
								class=
								"x.y.service.extras.SimpleBarService"
								/>
								<!-- ... and these two beans won't -->
								<bean
								id=
								"anotherService"
								class=
								"org.xyz.SomeService"
								/>
								<!-- (not in the right package) -->
								<bean
								id=
								"barManager"
								class=
								"x.y.service.SimpleBarManager"
								/>
								<!-- (doesn't end in 'Service') -->
								<tx:advice
								id=
								"txAdvice"
								>
								<tx:attributes>
								<tx:method
								name=
								"get*"
								read-only=
								"true"
								/>
								<tx:method
								name=
								"*"
								/>
								</tx:attributes>
								</tx:advice>
								<!-- other transaction infrastructure beans such as a PlatformTransactionManager omitted... -->
								</beans>

The following example shows how to configure two distinct beans with totally different transactional settings.

								<?xml version="1.0" encoding="UTF-8"?>
								<beans
								xmlns=
								"http://www.springframework.org/schema/beans"
								xmlns:xsi=
								"http://www.w3.org/2001/XMLSchema-instance"
								xmlns:aop=
								"http://www.springframework.org/schema/aop"
								xmlns:tx=
								"http://www.springframework.org/schema/tx"
								xsi:schemaLocation=
								" http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd"
								>
								<aop:config>
								<aop:pointcut
								id=
								"defaultServiceOperation"
								expression=
								"execution(* x.y.service.*Service.*(..))"
								/>
								<aop:pointcut
								id=
								"noTxServiceOperation"
								expression=
								"execution(* x.y.service.ddl.DefaultDdlManager.*(..))"
								/>
								<aop:advisor
								pointcut-ref=
								"defaultServiceOperation"
								advice-ref=
								"defaultTxAdvice"
								/>
								<aop:advisor
								pointcut-ref=
								"noTxServiceOperation"
								advice-ref=
								"noTxAdvice"
								/>
								</aop:config>
								<!-- this bean will be transactional (see the 'defaultServiceOperation' pointcut) -->
								<bean
								id=
								"fooService"
								class=
								"x.y.service.DefaultFooService"
								/>
								<!-- this bean will also be transactional, but with totally different transactional settings -->
								<bean
								id=
								"anotherFooService"
								class=
								"x.y.service.ddl.DefaultDdlManager"
								/>
								<tx:advice
								id=
								"defaultTxAdvice"
								>
								<tx:attributes>
								<tx:method
								name=
								"get*"
								read-only=
								"true"
								/>
								<tx:method
								name=
								"*"
								/>
								</tx:attributes>
								</tx:advice>
								<tx:advice
								id=
								"noTxAdvice"
								>
								<tx:attributes>
								<tx:method
								name=
								"*"
								propagation=
								"NEVER"
								/>
								</tx:attributes>
								</tx:advice>
								<!-- other transaction infrastructure beans such as a PlatformTransactionManager omitted... -->
								</beans>

17.5.5 <tx:advice/> settings

This section summarizes the various transactional settings that can be specified using the <tx:advice/>tag. The default <tx:advice/>settings are:

  • Propagation settingis REQUIRED.
  • Isolation level is DEFAULT.
  • Transaction is read/write.
  • Transaction timeout defaults to the default timeout of the underlying transaction system, or none if timeouts are not supported.
  • Any RuntimeExceptiontriggers rollback, and any checked Exceptiondoes not.

You can change these default settings; the various attributes of the <tx:method/>tags that are nested within <tx:advice/>and <tx:attributes/>tags are summarized below:

Table 17.1. <tx:method/> settings

Attribute Required? Default Description

name

Yes

  

Method name(s) with which the transaction attributes are to be associated. The wildcard (*) character can be used to associate the same transaction attribute settings with a number of methods; for example, get*, handle*, on*Event, and so forth.

propagation

No

REQUIRED

Transaction propagation behavior.

isolation

No

DEFAULT

Transaction isolation level.

timeout

No

-1

Transaction timeout value (in seconds).

read-only

No

false

Is this transaction read-only?

rollback-for

No

  

Exception(s)that trigger rollback; comma-delimited. For example, com.foo.MyBusinessException,ServletException.

no-rollback-for

No

  

Exception(s)that do nottrigger rollback; comma-delimited. For example, com.foo.MyBusinessException,ServletException.

17.5.6 Using @Transactional

In addition to the XML-based declarative approach to transaction configuration, you can use an annotation-based approach. Declaring transaction semantics directly in the Java source code puts the declarations much closer to the affected code. There is not much danger of undue coupling, because code that is meant to be used transactionally is almost always deployed that way anyway.

[Note] Note

The standard javax.transaction.Transactionalannotation is also supported as a drop-in replacement to Spring’s own annotation. Please refer to JTA 1.2 documentation for more details.

The ease-of-use afforded by the use of the @Transactionalannotation is best illustrated with an example, which is explained in the text that follows. Consider the following class definition:

								// the service class that we want to make transactional
								
									@Transactional
								public
								classDefaultFooService
								implementsFooService { Foo getFoo(String fooName); Foo getFoo(String fooName, String barName);
								voidinsertFoo(Foo foo);
								voidupdateFoo(Foo foo); }

When the above POJO is defined as a bean in a Spring IoC container, the bean instance can be made transactional by adding merely oneline of XML configuration:

								<!-- from the file 'context.xml' -->
								<?xml version="1.0" encoding="UTF-8"?>
								<beans
								xmlns=
								"http://www.springframework.org/schema/beans"
								xmlns:xsi=
								"http://www.w3.org/2001/XMLSchema-instance"
								xmlns:aop=
								"http://www.springframework.org/schema/aop"
								xmlns:tx=
								"http://www.springframework.org/schema/tx"
								xsi:schemaLocation=
								" http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd"
								>
								<!-- this is the service object that we want to make transactional -->
								<bean
								id=
								"fooService"
								class=
								"x.y.service.DefaultFooService"
								/>
								<!-- enable the configuration of transactional behavior based on annotations -->
								
									<tx:annotation-driven transaction-manager="txManager"/>
								<!-- a PlatformTransactionManager is still required -->
								<bean
								id=
								"txManager"
								class=
								"org.springframework.jdbc.datasource.DataSourceTransactionManager"
								>
								<!-- (this dependency is defined somewhere else) -->
								<property
								name=
								"dataSource"
								ref=
								"dataSource"
								/>
								</bean>
								<!-- other <bean/> definitions here -->
								</beans>
[Tip] Tip

You can omit the transaction-managerattribute in the <tx:annotation-driven/>tag if the bean name of the PlatformTransactionManagerthat you want to wire in has the name transactionManager. If the PlatformTransactionManagerbean that you want to dependency-inject has any other name, then you have to use the transaction-managerattribute explicitly, as in the preceding example.
[Note] Note

The @EnableTransactionManagementannotation provides equivalent support if you are using Java based configuration. Simply add the annotation to a @Configurationclass. See the javadocs for full details.

Method visibility and @Transactional

When using proxies, you should apply the @Transactionalannotation only to methods with publicvisibility. If you do annotate protected, private or package-visible methods with the @Transactionalannotation, no error is raised, but the annotated method does not exhibit the configured transactional settings. Consider the use of AspectJ (see below) if you need to annotate non-public methods.

You can place the @Transactionalannotation before an interface definition, a method on an interface, a class definition, or a publicmethod on a class. However, the mere presence of the @Transactionalannotation is not enough to activate the transactional behavior. The @Transactionalannotation is simply metadata that can be consumed by some runtime infrastructure that is @Transactional-aware and that can use the metadata to configure the appropriate beans with transactional behavior. In the preceding example, the <tx:annotation-driven/>element switches onthe transactional behavior.

[Tip] Tip

Spring recommends that you only annotate concrete classes (and methods of concrete classes) with the @Transactionalannotation, as opposed to annotating interfaces. You certainly can place the @Transactionalannotation on an interface (or an interface method), but this works only as you would expect it to if you are using interface-based proxies. The fact that Java annotations are not inherited from interfacesmeans that if you are using class-based proxies ( proxy-target-class="true") or the weaving-based aspect ( mode="aspectj"), then the transaction settings are not recognized by the proxying and weaving infrastructure, and the object will not be wrapped in a transactional proxy, which would be decidedly bad.
[Note] Note

In proxy mode (which is the default), only external method calls coming in through the proxy are intercepted. This means that self-invocation, in effect, a method within the target object calling another method of the target object, will not lead to an actual transaction at runtime even if the invoked method is marked with @Transactional. Also, the proxy must be fully initialized to provide the expected behaviour so you should not rely on this feature in your initialization code, i.e. @PostConstruct.

Consider the use of AspectJ mode (see mode attribute in table below) if you expect self-invocations to be wrapped with transactions as well. In this case, there will not be a proxy in the first place; instead, the target class will be weaved (that is, its byte code will be modified) in order to turn @Transactionalinto runtime behavior on any kind of method.

Table 17.2. Annotation driven transaction settings

XML Attribute Annotation Attribute Default Description

transaction-manager

N/A (See TransactionManagementConfigurerjavadocs)

transactionManager

Name of transaction manager to use. Only required if the name of the transaction manager is not transactionManager, as in the example above.

mode

mode

proxy

The default mode "proxy" processes annotated beans to be proxied using Spring’s AOP framework (following proxy semantics, as discussed above, applying to method calls coming in through the proxy only). The alternative mode "aspectj" instead weaves the affected classes with Spring’s AspectJ transaction aspect, modifying the target class byte code to apply to any kind of method call. AspectJ weaving requires spring-aspects.jar in the classpath as well as load-time weaving (or compile-time weaving) enabled. (See the section called “Spring configuration”for details on how to set up load-time weaving.)

proxy-target-class

proxyTargetClass

false

Applies to proxy mode only. Controls what type of transactional proxies are created for classes annotated with the @Transactionalannotation. If the proxy-target-classattribute is set to true, then class-based proxies are created. If proxy-target-classis falseor if the attribute is omitted, then standard JDK interface-based proxies are created. (See Section 11.6, “Proxying mechanisms”for a detailed examination of the different proxy types.)

order

order

Ordered.LOWEST_PRECEDENCE

Defines the order of the transaction advice that is applied to beans annotated with @Transactional. (For more information about the rules related to ordering of AOP advice, see the section called “Advice ordering”.) No specified ordering means that the AOP subsystem determines the order of the advice.

[Note] Note

The proxy-target-classattribute controls what type of transactional proxies are created for classes annotated with the @Transactionalannotation. If proxy-target-classis set to true, class-based proxies are created. If proxy-target-classis falseor if the attribute is omitted, standard JDK interface-based proxies are created. (See Section 11.6, “Proxying mechanisms”for a discussion of the different proxy types.)
[Note] Note

@EnableTransactionManagementand <tx:annotation-driven/>only looks for @Transactionalon beans in the same application context they are defined in. This means that, if you put annotation driven configuration in a WebApplicationContextfor a DispatcherServlet, it only checks for @Transactionalbeans in your controllers, and not your services. See Section 22.2, “The DispatcherServlet”for more information.

The most derived location takes precedence when evaluating the transactional settings for a method. In the case of the following example, the DefaultFooServiceclass is annotated at the class level with the settings for a read-only transaction, but the @Transactionalannotation on the updateFoo(Foo)method in the same class takes precedence over the transactional settings defined at the class level.

								
									@Transactional(readOnly = true)
								public
								classDefaultFooService
								implementsFooService {
								publicFoo getFoo(String fooName) {
								// do something}
								// these settings have precedence for this method
								
									@Transactional(readOnly = false, propagation = Propagation.REQUIRES_NEW)
								public
								voidupdateFoo(Foo foo) {
								// do something} }

@Transactional settings

The @Transactionalannotation is metadata that specifies that an interface, class, or method must have transactional semantics; for example, " start a brand new read-only transaction when this method is invoked, suspending any existing transaction". The default @Transactionalsettings are as follows:

  • Propagation setting is PROPAGATION_REQUIRED.
  • Isolation level is ISOLATION_DEFAULT.
  • Transaction is read/write.
  • Transaction timeout defaults to the default timeout of the underlying transaction system, or to none if timeouts are not supported.
  • Any RuntimeExceptiontriggers rollback, and any checked Exceptiondoes not.

These default settings can be changed; the various properties of the @Transactionalannotation are summarized in the following table:

Table 17.3. @Transactional Settings

Property Type Description

value

String

Optional qualifier specifying the transaction manager to be used.

propagation

enum: Propagation

Optional propagation setting.

isolation

enum: Isolation

Optional isolation level.

readOnly

boolean

Read/write vs. read-only transaction

timeout

int (in seconds granularity)

Transaction timeout.

rollbackFor

Array of Classobjects, which must be derived from Throwable.

Optional array of exception classes that mustcause rollback.

rollbackForClassName

Array of class names. Classes must be derived from Throwable.

Optional array of names of exception classes that mustcause rollback.

noRollbackFor

Array of Classobjects, which must be derived from Throwable.

Optional array of exception classes that must notcause rollback.

noRollbackForClassName

Array of Stringclass names, which must be derived from Throwable.

Optional array of names of exception classes that must notcause rollback.

Currently you cannot have explicit control over the name of a transaction, where 'name' means the transaction name that will be shown in a transaction monitor, if applicable (for example, WebLogic’s transaction monitor), and in logging output. For declarative transactions, the transaction name is always the fully-qualified class name + "." + method name of the transactionally-advised class. For example, if the handlePayment(..)method of the BusinessServiceclass started a transaction, the name of the transaction would be: com.foo.BusinessService.handlePayment.

Multiple Transaction Managers with @Transactional

Most Spring applications only need a single transaction manager, but there may be situations where you want multiple independent transaction managers in a single application. The value attribute of the @Transactionalannotation can be used to optionally specify the identity of the PlatformTransactionManagerto be used. This can either be the bean name or the qualifier value of the transaction manager bean. For example, using the qualifier notation, the following Java code

									public
									classTransactionalService {
									
										@Transactional("order")
									public
									voidsetSomething(String name) { ... }
									
										@Transactional("account")
									public
									voiddoSomething() { ... } }

could be combined with the following transaction manager bean declarations in the application context.

									<tx:annotation-driven/>
									<bean
									id=
									"transactionManager1"
									class=
									"org.springframework.jdbc.datasource.DataSourceTransactionManager"
									>...
									<qualifier
									value=
									"order"
									/>
									</bean>
									<bean
									id=
									"transactionManager2"
									class=
									"org.springframework.jdbc.datasource.DataSourceTransactionManager"
									>...
									<qualifier
									value=
									"account"
									/>
									</bean>

In this case, the two methods on TransactionalServicewill run under separate transaction managers, differentiated by the "order" and "account" qualifiers. The default <tx:annotation-driven>target bean name transactionManagerwill still be used if no specifically qualified PlatformTransactionManager bean is found.

Custom shortcut annotations

If you find you are repeatedly using the same attributes with @Transactionalon many different methods, then Spring’s meta-annotation supportallows you to define custom shortcut annotations for your specific use cases. For example, defining the following annotations

									
										@Target({ElementType.METHOD, ElementType.TYPE})
									
										@Retention(RetentionPolicy.RUNTIME)
									
										@Transactional("order")
									public
									
										@interfaceOrderTx { }
									
										@Target({ElementType.METHOD, ElementType.TYPE})
									
										@Retention(RetentionPolicy.RUNTIME)
									
										@Transactional("account")
									public
									
										@interfaceAccountTx { }

allows us to write the example from the previous section as

									public
									classTransactionalService {
									
										@OrderTx
									public
									voidsetSomething(String name) { ... }
									
										@AccountTx
									public
									voiddoSomething() { ... } }

Here we have used the syntax to define the transaction manager qualifier, but could also have included propagation behavior, rollback rules, timeouts etc.

17.5.7 Transaction propagation

This section describes some semantics of transaction propagation in Spring. Please note that this section is not an introduction to transaction propagation proper; rather it details some of the semantics regarding transaction propagation in Spring.

In Spring-managed transactions, be aware of the difference between physicaland logicaltransactions, and how the propagation setting applies to this difference.

Required

tx prop required

PROPAGATION_REQUIRED

When the propagation setting is PROPAGATION_REQUIRED, a logicaltransaction scope is created for each method upon which the setting is applied. Each such logical transaction scope can determine rollback-only status individually, with an outer transaction scope being logically independent from the inner transaction scope. Of course, in case of standard PROPAGATION_REQUIREDbehavior, all these scopes will be mapped to the same physical transaction. So a rollback-only marker set in the inner transaction scope does affect the outer transaction’s chance to actually commit (as you would expect it to).

However, in the case where an inner transaction scope sets the rollback-only marker, the outer transaction has not decided on the rollback itself, and so the rollback (silently triggered by the inner transaction scope) is unexpected. A corresponding UnexpectedRollbackExceptionis thrown at that point. This is expected behaviorso that the caller of a transaction can never be misled to assume that a commit was performed when it really was not. So if an inner transaction (of which the outer caller is not aware) silently marks a transaction as rollback-only, the outer caller still calls commit. The outer caller needs to receive an UnexpectedRollbackExceptionto indicate clearly that a rollback was performed instead.

RequiresNew

tx prop requires new

PROPAGATION_REQUIRES_NEW

PROPAGATION_REQUIRES_NEW, in contrast to PROPAGATION_REQUIRED, uses a completelyindependent transaction for each affected transaction scope. In that case, the underlying physical transactions are different and hence can commit or roll back independently, with an outer transaction not affected by an inner transaction’s rollback status.

Nested

PROPAGATION_NESTEDuses a singlephysical transaction with multiple savepoints that it can roll back to. Such partial rollbacks allow an inner transaction scope to trigger a rollback for its scope, with the outer transaction being able to continue the physical transaction despite some operations having been rolled back. This setting is typically mapped onto JDBC savepoints, so will only work with JDBC resource transactions. See Spring’s DataSourceTransactionManager.

17.5.8 Advising transactional operations

Suppose you want to execute bothtransactional andsome basic profiling advice. How do you effect this in the context of <tx:annotation-driven/>?

When you invoke the updateFoo(Foo)method, you want to see the following actions:

  • Configured profiling aspect starts up.
  • Transactional advice executes.
  • Method on the advised object executes.
  • Transaction commits.
  • Profiling aspect reports exact duration of the whole transactional method invocation.
[Note] Note

This chapter is not concerned with explaining AOP in any great detail (except as it applies to transactions). See Chapter 11, Aspect Oriented Programming with Spring for detailed coverage of the following AOP configuration and AOP in general.

Here is the code for a simple profiling aspect discussed above. The ordering of advice is controlled through the Orderedinterface. For full details on advice ordering, see the section called “Advice ordering”. .

								packagex.y;
								importorg.aspectj.lang.ProceedingJoinPoint;
								importorg.springframework.util.StopWatch;
								importorg.springframework.core.Ordered;
								public
								classSimpleProfiler
								implementsOrdered {
								private
								intorder;
								// allows us to control the ordering of advice
								public
								intgetOrder() {
								return
								this.order; }
								public
								voidsetOrder(
								intorder) {
								this.order = order; }
								// this method
								
									isthe around advice
								publicObject profile(ProceedingJoinPoint call)
								throwsThrowable { Object returnValue; StopWatch clock =
								newStopWatch(getClass().getName());
								try{ clock.start(call.toShortString()); returnValue = call.proceed(); }
								finally{ clock.stop(); System.out.println(clock.prettyPrint()); }
								returnreturnValue; } }
								<?xml version="1.0" encoding="UTF-8"?>
								<beans
								xmlns=
								"http://www.springframework.org/schema/beans"
								xmlns:xsi=
								"http://www.w3.org/2001/XMLSchema-instance"
								xmlns:aop=
								"http://www.springframework.org/schema/aop"
								xmlns:tx=
								"http://www.springframework.org/schema/tx"
								xsi:schemaLocation=
								" http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd"
								>
								<bean
								id=
								"fooService"
								class=
								"x.y.service.DefaultFooService"
								/>
								<!-- this is the aspect -->
								<bean
								id=
								"profiler"
								class=
								"x.y.SimpleProfiler"
								>
								<!-- execute before the transactional advice (hence the lower order number) -->
								<property
								name=
								"order"
								__value=
								"1"
								__/>
								</bean>
								<tx:annotation-driven
								transaction-manager=
								"txManager"
								__order=
								"200"
								__/>
								<aop:config>
								<!--
								this
								advice
								will
								execute
								around
								the
								transactional
								advice
								-->
								<aop:aspect
								id=
								"profilingAspect"
								ref=
								"profiler"
								>
								<aop:pointcut
								id=
								"serviceMethodWithReturnValue"
								expression=
								"execution(!void x.y..*Service.*(..))"
								/>
								<aop:around
								method=
								"profile"
								pointcut-ref=
								"serviceMethodWithReturnValue"
								/>
								</aop:aspect>
								</aop:config>
								<bean
								id=
								"dataSource"
								class=
								"org.apache.commons.dbcp.BasicDataSource"
								destroy-method=
								"close"
								>
								<property
								name=
								"driverClassName"
								value=
								"oracle.jdbc.driver.OracleDriver"
								/>
								<property
								name=
								"url"
								value=
								"jdbc:oracle:thin:@rj-t42:1521:elvis"
								/>
								<property
								name=
								"username"
								value=
								"scott"
								/>
								<property
								name=
								"password"
								value=
								"tiger"
								/>
								</bean>
								<bean
								id=
								"txManager"
								class=
								"org.springframework.jdbc.datasource.DataSourceTransactionManager"
								>
								<property
								name=
								"dataSource"
								ref=
								"dataSource"
								/>
								</bean>
								</beans>

The result of the above configuration is a fooServicebean that has profiling and transactional aspects applied to it in the desired order. You configure any number of additional aspects in similar fashion.

The following example effects the same setup as above, but uses the purely XML declarative approach.

								<?xml version="1.0" encoding="UTF-8"?>
								<beans
								xmlns=
								"http://www.springframework.org/schema/beans"
								xmlns:xsi=
								"http://www.w3.org/2001/XMLSchema-instance"
								xmlns:aop=
								"http://www.springframework.org/schema/aop"
								xmlns:tx=
								"http://www.springframework.org/schema/tx"
								xsi:schemaLocation=
								" http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd"
								>
								<bean
								id=
								"fooService"
								class=
								"x.y.service.DefaultFooService"
								/>
								<!-- the profiling advice -->
								<bean
								id=
								"profiler"
								class=
								"x.y.SimpleProfiler"
								>
								<!-- execute before the transactional advice (hence the lower order number) -->__
								<property
								name=
								"order"
								value=
								"1__"
								/>
								</bean>
								<aop:config>
								<aop:pointcut
								id=
								"entryPointMethod"
								expression=
								"execution(* x.y..*Service.*(..))"
								/>
								<!-- will execute after the profiling advice (c.f. the order attribute) -->
								<aop:advisor
								advice-ref=
								"txAdvice"
								pointcut-ref=
								"entryPointMethod"
								__order=
								"2__"
								/>
								<!-- order value is higher than the profiling aspect -->
								<aop:aspect
								id=
								"profilingAspect"
								ref=
								"profiler"
								>
								<aop:pointcut
								id=
								"serviceMethodWithReturnValue"
								expression=
								"execution(!void x.y..*Service.*(..))"
								/>
								<aop:around
								method=
								"profile"
								pointcut-ref=
								"serviceMethodWithReturnValue"
								/>
								</aop:aspect>
								</aop:config>
								<tx:advice
								id=
								"txAdvice"
								transaction-manager=
								"txManager"
								>
								<tx:attributes>
								<tx:method
								name=
								"get*"
								read-only=
								"true"
								/>
								<tx:method
								name=
								"*"
								/>
								</tx:attributes>
								</tx:advice>
								<!-- other <bean/> definitions such as a DataSource and a PlatformTransactionManager here -->
								</beans>

The result of the above configuration will be a fooServicebean that has profiling and transactional aspects applied to it in that order. If you want the profiling advice to execute afterthe transactional advice on the way in, and beforethe transactional advice on the way out, then you simply swap the value of the profiling aspect bean’s orderproperty so that it is higher than the transactional advice’s order value.

You configure additional aspects in similar fashion.

17.5.9 Using @Transactional with AspectJ

It is also possible to use the Spring Framework’s @Transactionalsupport outside of a Spring container by means of an AspectJ aspect. To do so, you first annotate your classes (and optionally your classes' methods) with the @Transactionalannotation, and then you link (weave) your application with the org.springframework.transaction.aspectj.AnnotationTransactionAspectdefined in the spring-aspects.jarfile. The aspect must also be configured with a transaction manager. You can of course use the Spring Framework’s IoC container to take care of dependency-injecting the aspect. The simplest way to configure the transaction management aspect is to use the <tx:annotation-driven/>element and specify the modeattribute to aspectjas described in Section 17.5.6, “Using @Transactional”. Because we’re focusing here on applications running outside of a Spring container, we’ll show you how to do it programmatically.

[Note] Note

Prior to continuing, you may want to read Section 17.5.6, “Using @Transactional”and Chapter 11, Aspect Oriented Programming with Spring respectively.

 
								// construct an appropriate transaction managerDataSourceTransactionManager txManager =
								newDataSourceTransactionManager(getDataSource());
								// configure the AnnotationTransactionAspect to use it; this must be done before executing any transactional methodsAnnotationTransactionAspect.aspectOf().setTransactionManager(txManager);
[Note] Note

When using this aspect, you must annotate the implementationclass (and/or methods within that class), notthe interface (if any) that the class implements. AspectJ follows Java’s rule that annotations on interfaces are not inherited.

The @Transactionalannotation on a class specifies the default transaction semantics for the execution of any method in the class.

The @Transactionalannotation on a method within the class overrides the default transaction semantics given by the class annotation (if present). Any method may be annotated, regardless of visibility.

To weave your applications with the AnnotationTransactionAspectyou must either build your application with AspectJ (see the AspectJ Development Guide) or use load-time weaving. See Section 11.8.4, “Load-time weaving with AspectJ in the Spring Framework”for a discussion of load-time weaving with AspectJ.

17.6 Programmatic transaction management

The Spring Framework provides two means of programmatic transaction management:

  • Using the TransactionTemplate.
  • Using a PlatformTransactionManagerimplementation directly.

The Spring team generally recommends the TransactionTemplatefor programmatic transaction management. The second approach is similar to using the JTA UserTransactionAPI, although exception handling is less cumbersome.

17.6.1 Using the TransactionTemplate

The TransactionTemplateadopts the same approach as other Spring templatessuch as the JdbcTemplate. It uses a callback approach, to free application code from having to do the boilerplate acquisition and release of transactional resources, and results in code that is intention driven, in that the code that is written focuses solely on what the developer wants to do.

[Note] Note

As you will see in the examples that follow, using the TransactionTemplateabsolutely couples you to Spring’s transaction infrastructure and APIs. Whether or not programmatic transaction management is suitable for your development needs is a decision that you will have to make yourself.

Application code that must execute in a transactional context, and that will use the TransactionTemplateexplicitly, looks like the following. You, as an application developer, write a TransactionCallbackimplementation (typically expressed as an anonymous inner class) that contains the code that you need to execute in the context of a transaction. You then pass an instance of your custom TransactionCallbackto the execute(..)method exposed on the TransactionTemplate.

								public
								classSimpleService
								implementsService {
								// single TransactionTemplate shared amongst all methods in this instance
								private
								finalTransactionTemplate transactionTemplate;
								// use constructor-injection to supply the PlatformTransactionManager
								publicSimpleService(PlatformTransactionManager transactionManager) { Assert.notNull(transactionManager,
								"The 'transactionManager' argument must not be null.");
								this.transactionTemplate =
								newTransactionTemplate(transactionManager); }
								publicObject someServiceMethod() {
								returntransactionTemplate.execute(
								newTransactionCallback() {
								// the code in this method executes in a transactional context
								publicObject doInTransaction(TransactionStatus status) { updateOperation1();
								returnresultOfUpdateOperation2(); } }); } }

If there is no return value, use the convenient TransactionCallbackWithoutResultclass with an anonymous class as follows:

transactionTemplate.execute(
								new
								
									TransactionCallbackWithoutResult() {
								protected
								voiddoInTransactionWithoutResult(TransactionStatus status) { updateOperation1(); updateOperation2(); } });

Code within the callback can roll the transaction back by calling the setRollbackOnly()method on the supplied TransactionStatusobject:

transactionTemplate.execute(
								newTransactionCallbackWithoutResult() {
								protected
								voiddoInTransactionWithoutResult(TransactionStatus status) {
								try{ updateOperation1(); updateOperation2(); }
								catch(SomeBusinessExeption ex) {
								
									status.setRollbackOnly();} } });

Specifying transaction settings

You can specify transaction settings such as the propagation mode, the isolation level, the timeout, and so forth on the TransactionTemplateeither programmatically or in configuration. TransactionTemplateinstances by default have the default transactional settings. The following example shows the programmatic customization of the transactional settings for a specific TransactionTemplate:

									public
									classSimpleService
									implementsService {
									private
									finalTransactionTemplate transactionTemplate;
									publicSimpleService(PlatformTransactionManager transactionManager) { Assert.notNull(transactionManager,
									"The 'transactionManager' argument must not be null.");
									this.transactionTemplate =
									newTransactionTemplate(transactionManager);
									// the transaction settings can be set here explicitly if so desired
									this.transactionTemplate.setIsolationLevel(TransactionDefinition.ISOLATION_READ_UNCOMMITTED);
									this.transactionTemplate.setTimeout(
									30);
									// 30 seconds
									// and so forth...} }

The following example defines a TransactionTemplatewith some custom transactional settings, using Spring XML configuration. The sharedTransactionTemplatecan then be injected into as many services as are required.

									<bean
									id=
									"sharedTransactionTemplate"
									class=
									"org.springframework.transaction.support.TransactionTemplate"
									>
									<property
									name=
									"isolationLevelName"
									value=
									"ISOLATION_READ_UNCOMMITTED"
									/>
									<property
									name=
									"timeout"
									value=
									"30"
									/>
									</bean>"

Finally, instances of the TransactionTemplateclass are threadsafe, in that instances do not maintain any conversational state. TransactionTemplateinstances dohowever maintain configuration state, so while a number of classes may share a single instance of a TransactionTemplate, if a class needs to use a TransactionTemplatewith different settings (for example, a different isolation level), then you need to create two distinct TransactionTemplateinstances.

17.6.2 Using the PlatformTransactionManager

You can also use the org.springframework.transaction.PlatformTransactionManagerdirectly to manage your transaction. Simply pass the implementation of the PlatformTransactionManageryou are using to your bean through a bean reference. Then, using the TransactionDefinitionand TransactionStatusobjects you can initiate transactions, roll back, and commit.

DefaultTransactionDefinition def =
								newDefaultTransactionDefinition();
								// explicitly setting the transaction name is something that can only be done programmaticallydef.setName(
								"SomeTxName"); def.setPropagationBehavior(TransactionDefinition.PROPAGATION_REQUIRED); TransactionStatus status = txManager.getTransaction(def);
								try{
								// execute your business logic here}
								catch(MyException ex) { txManager.rollback(status);
								throwex; } txManager.commit(status);

17.7 Choosing between programmatic and declarative transaction management

Programmatic transaction management is usually a good idea only if you have a small number of transactional operations. For example, if you have a web application that require transactions only for certain update operations, you may not want to set up transactional proxies using Spring or any other technology. In this case, using the TransactionTemplate maybe a good approach. Being able to set the transaction name explicitly is also something that can only be done using the programmatic approach to transaction management.

On the other hand, if your application has numerous transactional operations, declarative transaction management is usually worthwhile. It keeps transaction management out of business logic, and is not difficult to configure. When using the Spring Framework, rather than EJB CMT, the configuration cost of declarative transaction management is greatly reduced.

17.8 Transaction bound event

As of Spring 4.2, the listener of an event can be bound to a phase of the transaction. The typical example is to handle the event when the transaction has completed successfully: this allows events to be used with more flexibility when the outcome of the current transaction actually matters to the listener.

Registering a regular event listener is done via the @EventListenerannotation. If you need to bind it to the transaction use @TransactionalEventListener. When you do so, the listener will be bound to the commit phase of the transaction by default.

Let’s take an example to illustrate this concept. Assume that a component publish an order created event and we want to define a listener that should only handle that event once the transaction in which it has been published as committed successfully:

							
								@Component
							public
							classMyComponent {
							
								@TransactionalEventListener
							public
							voidhandleOrderCreatedEvent(CreationEvent<Order> creationEvent) { ... } }

The TransactionalEventListenerannotation exposes a phaseattribute that allows to customize to which phase of the transaction the listener should be bound to. The valid phases are BEFORE_COMMIT, AFTER_COMMIT(default), AFTER_ROLLBACKand AFTER_COMPLETIONthat aggregates the transaction completion (be it a commit or a rollback).

If no transaction is running, the listener is not invoked at all since we can’t honor the required semantics. It is however possible to override that behaviour by setting the fallbackExecutionattribute of the annotation to true.

17.9 Application server-specific integration

Spring’s transaction abstraction generally is application server agnostic. Additionally, Spring’s JtaTransactionManagerclass, which can optionally perform a JNDI lookup for the JTA UserTransactionand TransactionManagerobjects, autodetects the location for the latter object, which varies by application server. Having access to the JTA TransactionManagerallows for enhanced transaction semantics, in particular supporting transaction suspension. See the JtaTransactionManagerjavadocs for details.

Spring’s JtaTransactionManageris the standard choice to run on Java EE application servers, and is known to work on all common servers. Advanced functionality such as transaction suspension works on many servers as well — including GlassFish, JBoss and Geronimo — without any special configuration required. However, for fully supported transaction suspension and further advanced integration, Spring ships special adapters for WebLogic Server and WebSphere. These adapters are discussed in the following sections.

For standard scenarios, including WebLogic Server and WebSphere, consider using the convenient <tx:jta-transaction-manager/>configuration element.When configured, this element automatically detects the underlying server and chooses the best transaction manager available for the platform. This means that you won’t have to configure server-specific adapter classes (as discussed in the following sections) explicitly; rather, they are chosen automatically, with the standard JtaTransactionManageras default fallback.

17.9.1 IBM WebSphere

On WebSphere 6.1.0.9 and above, the recommended Spring JTA transaction manager to use is WebSphereUowTransactionManager. This special adapter leverages IBM’s UOWManagerAPI, which is available in WebSphere Application Server 6.0.2.19 and later and 6.1.0.9 and later. With this adapter, Spring-driven transaction suspension (suspend/resume as initiated by PROPAGATION_REQUIRES_NEW) is officially supported by IBM!

17.9.2 Oracle WebLogic Server

On WebLogic Server 9.0 or above, you typically would use the WebLogicJtaTransactionManagerinstead of the stock JtaTransactionManagerclass. This special WebLogic-specific subclass of the normal JtaTransactionManagersupports the full power of Spring’s transaction definitions in a WebLogic-managed transaction environment, beyond standard JTA semantics: Features include transaction names, per-transaction isolation levels, and proper resuming of transactions in all cases.

17.10 Solutions to common problems

17.10.1 Use of the wrong transaction manager for a specific DataSource

Use the correct PlatformTransactionManagerimplementation based on your choice of transactional technologies and requirements. Used properly, the Spring Framework merely provides a straightforward and portable abstraction. If you are using global transactions, you mustuse the org.springframework.transaction.jta.JtaTransactionManagerclass (or an application server-specific subclassof it) for all your transactional operations. Otherwise the transaction infrastructure attempts to perform local transactions on resources such as container DataSourceinstances. Such local transactions do not make sense, and a good application server treats them as errors.

17.11 Further Resources

For more information about the Spring Framework’s transaction support:

  • Distributed transactions in Spring, with and without XAis a JavaWorld presentation in which Spring’s David Syer guides you through seven patterns for distributed transactions in Spring applications, three of them with XA and four without.
  • Java Transaction Design Strategiesis a book available from InfoQthat provides a well-paced introduction to transactions in Java. It also includes side-by-side examples of how to configure and use transactions with both the Spring Framework and EJB3.

18. DAO support

18.1 Introduction

The Data Access Object (DAO) support in Spring is aimed at making it easy to work with data access technologies like JDBC, Hibernate, JPA or JDO in a consistent way. This allows one to switch between the aforementioned persistence technologies fairly easily and it also allows one to code without worrying about catching exceptions that are specific to each technology.

18.2 Consistent exception hierarchy

Spring provides a convenient translation from technology-specific exceptions like SQLExceptionto its own exception class hierarchy with the DataAccessExceptionas the root exception. These exceptions wrap the original exception so there is never any risk that one might lose any information as to what might have gone wrong.

In addition to JDBC exceptions, Spring can also wrap Hibernate-specific exceptions, converting them to a set of focused runtime exceptions (the same is true for JDO and JPA exceptions). This allows one to handle most persistence exceptions, which are non-recoverable, only in the appropriate layers, without having annoying boilerplate catch-and-throw blocks and exception declarations in one’s DAOs. (One can still trap and handle exceptions anywhere one needs to though.) As mentioned above, JDBC exceptions (including database-specific dialects) are also converted to the same hierarchy, meaning that one can perform some operations with JDBC within a consistent programming model.

The above holds true for the various template classes in Springs support for various ORM frameworks. If one uses the interceptor-based classes then the application must care about handling HibernateExceptionsand JDOExceptionsitself, preferably via delegating to SessionFactoryUtils’ `convertHibernateAccessException(..)or convertJdoAccessException()methods respectively. These methods convert the exceptions to ones that are compatible with the exceptions in the org.springframework.daoexception hierarchy. As JDOExceptionsare unchecked, they can simply get thrown too, sacrificing generic DAO abstraction in terms of exceptions though.

The exception hierarchy that Spring provides can be seen below. (Please note that the class hierarchy detailed in the image shows only a subset of the entire DataAccessExceptionhierarchy.)

DataAccessException

18.3 Annotations used for configuring DAO or Repository classes

The best way to guarantee that your Data Access Objects (DAOs) or repositories provide exception translation is to use the @Repositoryannotation. This annotation also allows the component scanning support to find and configure your DAOs and repositories without having to provide XML configuration entries for them.

							
								@Repository
							public
							classSomeMovieFinder
							implementsMovieFinder {
							// ...}

Any DAO or repository implementation will need to access to a persistence resource, depending on the persistence technology used; for example, a JDBC-based repository will need access to a JDBC DataSource; a JPA-based repository will need access to an EntityManager. The easiest way to accomplish this is to have this resource dependency injected using one of the @Autowired,, @Inject, @Resourceor @PersistenceContextannotations. Here is an example for a JPA repository:

							
								@Repository
							public
							classJpaMovieFinder
							implementsMovieFinder {
							
								@PersistenceContext
							privateEntityManager entityManager;
							// ...}

If you are using the classic Hibernate APIs than you can inject the SessionFactory:

							
								@Repository
							public
							classHibernateMovieFinder
							implementsMovieFinder {
							privateSessionFactory sessionFactory;
							
								@Autowired
							public
							voidsetSessionFactory(SessionFactory sessionFactory) {
							this.sessionFactory = sessionFactory; }
							// ...}

Last example we will show here is for typical JDBC support. You would have the DataSourceinjected into an initialization method where you would create a JdbcTemplateand other data access support classes like SimpleJdbcCalletc using this DataSource.

							
								@Repository
							public
							classJdbcMovieFinder
							implementsMovieFinder {
							privateJdbcTemplate jdbcTemplate;
							
								@Autowired
							public
							voidinit(DataSource dataSource) {
							this.jdbcTemplate =
							newJdbcTemplate(dataSource); }
							// ...}
[Note] Note

Please see the specific coverage of each persistence technology for details on how to configure the application context to take advantage of these annotations.

19. Data access with JDBC

19.1 Introduction to Spring Framework JDBC

The value-add provided by the Spring Framework JDBC abstraction is perhaps best shown by the sequence of actions outlined in the table below. The table shows what actions Spring will take care of and which actions are the responsibility of you, the application developer.

Table 19.1. Spring JDBC - who does what?

Action Spring You

Define connection parameters.

  

X

Open the connection.

X

  

Specify the SQL statement.

  

X

Declare parameters and provide parameter values

  

X

Prepare and execute the statement.

X

  

Set up the loop to iterate through the results (if any).

X

  

Do the work for each iteration.

  

X

Process any exception.

X

  

Handle transactions.

X

  

Close the connection, statement and resultset.

X

  

The Spring Framework takes care of all the low-level details that can make JDBC such a tedious API to develop with.

19.1.1 Choosing an approach for JDBC database access

You can choose among several approaches to form the basis for your JDBC database access. In addition to three flavors of the JdbcTemplate, a new SimpleJdbcInsert and SimplejdbcCall approach optimizes database metadata, and the RDBMS Object style takes a more object-oriented approach similar to that of JDO Query design. Once you start using one of these approaches, you can still mix and match to include a feature from a different approach. All approaches require a JDBC 2.0-compliant driver, and some advanced features require a JDBC 3.0 driver.

  • JdbcTemplateis the classic Spring JDBC approach and the most popular. This "lowest level" approach and all others use a JdbcTemplate under the covers.
  • NamedParameterJdbcTemplatewraps a JdbcTemplateto provide named parameters instead of the traditional JDBC "?" placeholders. This approach provides better documentation and ease of use when you have multiple parameters for an SQL statement.
  • SimpleJdbcInsert and SimpleJdbcCalloptimize database metadata to limit the amount of necessary configuration. This approach simplifies coding so that you only need to provide the name of the table or procedure and provide a map of parameters matching the column names. This only works if the database provides adequate metadata. If the database doesn’t provide this metadata, you will have to provide explicit configuration of the parameters.
  • RDBMS Objects including MappingSqlQuery, SqlUpdate and StoredProcedurerequires you to create reusable and thread-safe objects during initialization of your data access layer. This approach is modeled after JDO Query wherein you define your query string, declare parameters, and compile the query. Once you do that, execute methods can be called multiple times with various parameter values passed in.

19.1.2 Package hierarchy

The Spring Framework’s JDBC abstraction framework consists of four different packages, namely core, datasource, object, and support.

The org.springframework.jdbc.corepackage contains the JdbcTemplateclass and its various callback interfaces, plus a variety of related classes. A subpackage named org.springframework.jdbc.core.simplecontains the SimpleJdbcInsertand SimpleJdbcCallclasses. Another subpackage named org.springframework.jdbc.core.namedparamcontains the NamedParameterJdbcTemplateclass and the related support classes. See Section 19.2, “Using the JDBC core classes to control basic JDBC processing and error handling”, Section 19.4, “JDBC batch operations”, and Section 19.5, “Simplifying JDBC operations with the SimpleJdbc classes”.

The org.springframework.jdbc.datasourcepackage contains a utility class for easy DataSourceaccess, and various simple DataSourceimplementations that can be used for testing and running unmodified JDBC code outside of a Java EE container. A subpackage named org.springfamework.jdbc.datasource.embeddedprovides support for creating embedded databases using Java database engines such as HSQL, H2, and Derby. See Section 19.3, “Controlling database connections”and Section 19.8, “Embedded database support”.

The org.springframework.jdbc.objectpackage contains classes that represent RDBMS queries, updates, and stored procedures as thread-safe, reusable objects. See Section 19.6, “Modeling JDBC operations as Java objects”. This approach is modeled by JDO, although objects returned by queries are naturally disconnectedfrom the database. This higher level of JDBC abstraction depends on the lower-level abstraction in the org.springframework.jdbc.corepackage.

The org.springframework.jdbc.supportpackage provides SQLExceptiontranslation functionality and some utility classes. Exceptions thrown during JDBC processing are translated to exceptions defined in the org.springframework.daopackage. This means that code using the Spring JDBC abstraction layer does not need to implement JDBC or RDBMS-specific error handling. All translated exceptions are unchecked, which gives you the option of catching the exceptions from which you can recover while allowing other exceptions to be propagated to the caller. See Section 19.2.3, “SQLExceptionTranslator”.

19.2 Using the JDBC core classes to control basic JDBC processing and error handling

19.2.1 JdbcTemplate

The JdbcTemplateclass is the central class in the JDBC core package. It handles the creation and release of resources, which helps you avoid common errors such as forgetting to close the connection. It performs the basic tasks of the core JDBC workflow such as statement creation and execution, leaving application code to provide SQL and extract results. The JdbcTemplateclass executes SQL queries, update statements and stored procedure calls, performs iteration over ResultSets and extraction of returned parameter values. It also catches JDBC exceptions and translates them to the generic, more informative, exception hierarchy defined in the org.springframework.daopackage.

When you use the JdbcTemplatefor your code, you only need to implement callback interfaces, giving them a clearly defined contract. The PreparedStatementCreatorcallback interface creates a prepared statement given a Connectionprovided by this class, providing SQL and any necessary parameters. The same is true for the CallableStatementCreatorinterface, which creates callable statements. The RowCallbackHandlerinterface extracts values from each row of a ResultSet.

The JdbcTemplatecan be used within a DAO implementation through direct instantiation with a DataSourcereference, or be configured in a Spring IoC container and given to DAOs as a bean reference.

[Note] Note

The DataSourceshould always be configured as a bean in the Spring IoC container. In the first case the bean is given to the service directly; in the second case it is given to the prepared template.

All SQL issued by this class is logged at the DEBUGlevel under the category corresponding to the fully qualified class name of the template instance (typically JdbcTemplate, but it may be different if you are using a custom subclass of the JdbcTemplateclass).

Examples of JdbcTemplate class usage

This section provides some examples of JdbcTemplateclass usage. These examples are not an exhaustive list of all of the functionality exposed by the JdbcTemplate; see the attendant javadocs for that.

Querying (SELECT)

Here is a simple query for getting the number of rows in a relation:

										introwCount =
										this.jdbcTemplate.queryForObject(
										"select count(*) from t_actor", Integer.
										class);

A simple query using a bind variable:

										intcountOfActorsNamedJoe =
										this.jdbcTemplate.queryForObject(
										"select count(*) from t_actor where first_name = ?", Integer.
										class,
										"Joe");

Querying for a String:

String lastName =
										this.jdbcTemplate.queryForObject(
										"select last_name from t_actor where id = ?",
										newObject[]{
										1212L}, String.
										class);

Querying and populating a singledomain object:

Actor actor =
										this.jdbcTemplate.queryForObject(
										"select first_name, last_name from t_actor where id = ?",
										newObject[]{
										1212L},
										newRowMapper<Actor>() {
										publicActor mapRow(ResultSet rs,
										introwNum)
										throwsSQLException { Actor actor =
										newActor(); actor.setFirstName(rs.getString(
										"first_name")); actor.setLastName(rs.getString(
										"last_name"));
										returnactor; } });

Querying and populating a number of domain objects:

List<Actor> actors =
										this.jdbcTemplate.query(
										"select first_name, last_name from t_actor",
										newRowMapper<Actor>() {
										publicActor mapRow(ResultSet rs,
										introwNum)
										throwsSQLException { Actor actor =
										newActor(); actor.setFirstName(rs.getString(
										"first_name")); actor.setLastName(rs.getString(
										"last_name"));
										returnactor; } });

If the last two snippets of code actually existed in the same application, it would make sense to remove the duplication present in the two RowMapperanonymous inner classes, and extract them out into a single class (typically a staticnested class) that can then be referenced by DAO methods as needed. For example, it may be better to write the last code snippet as follows:

										publicList<Actor> findAllActors() {
										return
										this.jdbcTemplate.query(
										"select first_name, last_name from t_actor",
										newActorMapper()); }
										private
										static
										final
										classActorMapper
										implementsRowMapper<Actor> {
										publicActor mapRow(ResultSet rs,
										introwNum)
										throwsSQLException { Actor actor =
										newActor(); actor.setFirstName(rs.getString(
										"first_name")); actor.setLastName(rs.getString(
										"last_name"));
										returnactor; } }
Updating (INSERT/UPDATE/DELETE) with jdbcTemplate

You use the update(..)method to perform insert, update and delete operations. Parameter values are usually provided as var args or alternatively as an object array.

										this.jdbcTemplate.update(
										"insert into t_actor (first_name, last_name) values (?, ?)",
										"Leonor",
										"Watling");
										this.jdbcTemplate.update(
										"update t_actor set last_name = ? where id = ?",
										"Banjo",
										5276L);
										this.jdbcTemplate.update(
										"delete from actor where id = ?", Long.valueOf(actorId));
Other jdbcTemplate operations

You can use the execute(..)method to execute any arbitrary SQL, and as such the method is often used for DDL statements. It is heavily overloaded with variants taking callback interfaces, binding variable arrays, and so on.

										this.jdbcTemplate.execute(
										"create table mytable (id integer, name varchar(100))");

The following example invokes a simple stored procedure. More sophisticated stored procedure support is covered later.

										this.jdbcTemplate.update(
										"call SUPPORT.REFRESH_ACTORS_SUMMARY(?)", Long.valueOf(unionId));

JdbcTemplate best practices

Instances of the JdbcTemplateclass are threadsafe once configured. This is important because it means that you can configure a single instance of a JdbcTemplateand then safely inject this sharedreference into multiple DAOs (or repositories). The JdbcTemplateis stateful, in that it maintains a reference to a DataSource, but this state is notconversational state.

A common practice when using the JdbcTemplateclass (and the associated NamedParameterJdbcTemplateclasses) is to configure a DataSourcein your Spring configuration file, and then dependency-inject that shared DataSourcebean into your DAO classes; the JdbcTemplateis created in the setter for the DataSource. This leads to DAOs that look in part like the following:

									public
									classJdbcCorporateEventDao
									implementsCorporateEventDao {
									privateJdbcTemplate jdbcTemplate;
									public
									voidsetDataSource(DataSource dataSource) {
									
										this.jdbcTemplate = new JdbcTemplate(dataSource);}
									// JDBC-backed implementations of the methods on the CorporateEventDao follow...}

The corresponding configuration might look like this.

									<?xml version="1.0" encoding="UTF-8"?>
									<beans
									xmlns=
									"http://www.springframework.org/schema/beans"
									xmlns:xsi=
									"http://www.w3.org/2001/XMLSchema-instance"
									xmlns:context=
									"http://www.springframework.org/schema/context"
									xsi:schemaLocation=
									" http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd"
									>
									<bean
									id=
									"corporateEventDao"
									class=
									"com.example.JdbcCorporateEventDao"
									>
									<property
									name=
									"dataSource"
									ref=
									"dataSource"
									/>
									</bean>
									<bean
									id=
									"dataSource"
									class=
									"org.apache.commons.dbcp.BasicDataSource"
									destroy-method=
									"close"
									>
									<property
									name=
									"driverClassName"
									value=
									"${jdbc.driverClassName}"
									/>
									<property
									name=
									"url"
									value=
									"${jdbc.url}"
									/>
									<property
									name=
									"username"
									value=
									"${jdbc.username}"
									/>
									<property
									name=
									"password"
									value=
									"${jdbc.password}"
									/>
									</bean>
									<context:property-placeholder
									location=
									"jdbc.properties"
									/>
									</beans>

An alternative to explicit configuration is to use component-scanning and annotation support for dependency injection. In this case you annotate the class with @Repository(which makes it a candidate for component-scanning) and annotate the DataSourcesetter method with @Autowired.

									
										@Repository
									public
									classJdbcCorporateEventDao
									implementsCorporateEventDao {
									privateJdbcTemplate jdbcTemplate;
									
										@Autowired
									public
									voidsetDataSource(DataSource dataSource) {
									
										this.jdbcTemplate = new JdbcTemplate(dataSource);}
									// JDBC-backed implementations of the methods on the CorporateEventDao follow...}

The corresponding XML configuration file would look like the following:

									<?xml version="1.0" encoding="UTF-8"?>
									<beans
									xmlns=
									"http://www.springframework.org/schema/beans"
									xmlns:xsi=
									"http://www.w3.org/2001/XMLSchema-instance"
									xmlns:context=
									"http://www.springframework.org/schema/context"
									xsi:schemaLocation=
									" http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd"
									>
									<!-- Scans within the base package of the application for @Component classes to configure as beans -->
									<context:component-scan
									base-package=
									"org.springframework.docs.test"
									/>
									<bean
									id=
									"dataSource"
									class=
									"org.apache.commons.dbcp.BasicDataSource"
									destroy-method=
									"close"
									>
									<property
									name=
									"driverClassName"
									value=
									"${jdbc.driverClassName}"
									/>
									<property
									name=
									"url"
									value=
									"${jdbc.url}"
									/>
									<property
									name=
									"username"
									value=
									"${jdbc.username}"
									/>
									<property
									name=
									"password"
									value=
									"${jdbc.password}"
									/>
									</bean>
									<context:property-placeholder
									location=
									"jdbc.properties"
									/>
									</beans>

If you are using Spring’s JdbcDaoSupportclass, and your various JDBC-backed DAO classes extend from it, then your sub-class inherits a setDataSource(..)method from the JdbcDaoSupportclass. You can choose whether to inherit from this class. The JdbcDaoSupportclass is provided as a convenience only.

Regardless of which of the above template initialization styles you choose to use (or not), it is seldom necessary to create a new instance of a JdbcTemplateclass each time you want to execute SQL. Once configured, a JdbcTemplateinstance is threadsafe. You may want multiple JdbcTemplateinstances if your application accesses multiple databases, which requires multiple DataSources, and subsequently multiple differently configured JdbcTemplates.

19.2.2 NamedParameterJdbcTemplate

The NamedParameterJdbcTemplateclass adds support for programming JDBC statements using named parameters, as opposed to programming JDBC statements using only classic placeholder ( '?') arguments. The NamedParameterJdbcTemplateclass wraps a JdbcTemplate, and delegates to the wrapped JdbcTemplateto do much of its work. This section describes only those areas of the NamedParameterJdbcTemplateclass that differ from the JdbcTemplateitself; namely, programming JDBC statements using named parameters.

								// some JDBC-backed DAO class...
								privateNamedParameterJdbcTemplate namedParameterJdbcTemplate;
								public
								voidsetDataSource(DataSource dataSource) {
								this.namedParameterJdbcTemplate =
								newNamedParameterJdbcTemplate(dataSource); }
								public
								intcountOfActorsByFirstName(String firstName) { String sql =
								"select count(*) from T_ACTOR where first_name = :first_name"; SqlParameterSource namedParameters =
								newMapSqlParameterSource(
								"first_name", firstName);
								return
								this.namedParameterJdbcTemplate.queryForObject(sql, namedParameters, Integer.
								class); }

Notice the use of the named parameter notation in the value assigned to the sqlvariable, and the corresponding value that is plugged into the namedParametersvariable (of type MapSqlParameterSource).

Alternatively, you can pass along named parameters and their corresponding values to a NamedParameterJdbcTemplateinstance by using the Map-based style.The remaining methods exposed by the NamedParameterJdbcOperationsand implemented by the NamedParameterJdbcTemplateclass follow a similar pattern and are not covered here.

The following example shows the use of the Map-based style.

								// some JDBC-backed DAO class...
								privateNamedParameterJdbcTemplate namedParameterJdbcTemplate;
								public
								voidsetDataSource(DataSource dataSource) {
								this.namedParameterJdbcTemplate =
								newNamedParameterJdbcTemplate(dataSource); }
								public
								intcountOfActorsByFirstName(String firstName) { String sql =
								"select count(*) from T_ACTOR where first_name = :first_name"; Map<String, String> namedParameters = Collections.singletonMap(
								"first_name", firstName);
								return
								this.namedParameterJdbcTemplate.queryForObject(sql, namedParameters, Integer.
								class); }

One nice feature related to the NamedParameterJdbcTemplate(and existing in the same Java package) is the SqlParameterSourceinterface. You have already seen an example of an implementation of this interface in one of the previous code snippet (the MapSqlParameterSourceclass). An SqlParameterSourceis a source of named parameter values to a NamedParameterJdbcTemplate. The MapSqlParameterSourceclass is a very simple implementation that is simply an adapter around a java.util.Map, where the keys are the parameter names and the values are the parameter values.

Another SqlParameterSourceimplementation is the BeanPropertySqlParameterSourceclass. This class wraps an arbitrary JavaBean (that is, an instance of a class that adheres to the JavaBean conventions), and uses the properties of the wrapped JavaBean as the source of named parameter values.

								public
								classActor {
								privateLong id;
								privateString firstName;
								privateString lastName;
								publicString getFirstName() {
								return
								this.firstName; }
								publicString getLastName() {
								return
								this.lastName; }
								publicLong getId() {
								return
								this.id; }
								// setters omitted...}
								// some JDBC-backed DAO class...
								privateNamedParameterJdbcTemplate namedParameterJdbcTemplate;
								public
								voidsetDataSource(DataSource dataSource) {
								this.namedParameterJdbcTemplate =
								newNamedParameterJdbcTemplate(dataSource); }
								public
								intcountOfActors(Actor exampleActor) {
								// notice how the named parameters match the properties of the above 'Actor' classString sql =
								"select count(*) from T_ACTOR where first_name = :firstName and last_name = :lastName"; SqlParameterSource namedParameters =
								newBeanPropertySqlParameterSource(exampleActor);
								return
								this.namedParameterJdbcTemplate.queryForObject(sql, namedParameters, Integer.
								class); }

Remember that the NamedParameterJdbcTemplateclass wrapsa classic JdbcTemplatetemplate; if you need access to the wrapped JdbcTemplateinstance to access functionality only present in the JdbcTemplateclass, you can use the getJdbcOperations()method to access the wrapped JdbcTemplatethrough the JdbcOperationsinterface.

See also the section called “JdbcTemplate best practices”for guidelines on using the NamedParameterJdbcTemplateclass in the context of an application.

19.2.3 SQLExceptionTranslator

SQLExceptionTranslatoris an interface to be implemented by classes that can translate between SQLExceptionsand Spring’s own org.springframework.dao.DataAccessException, which is agnostic in regard to data access strategy. Implementations can be generic (for example, using SQLState codes for JDBC) or proprietary (for example, using Oracle error codes) for greater precision.

SQLErrorCodeSQLExceptionTranslatoris the implementation of SQLExceptionTranslatorthat is used by default. This implementation uses specific vendor codes. It is more precise than the SQLStateimplementation. The error code translations are based on codes held in a JavaBean type class called SQLErrorCodes. This class is created and populated by an SQLErrorCodesFactorywhich as the name suggests is a factory for creating SQLErrorCodesbased on the contents of a configuration file named sql-error-codes.xml. This file is populated with vendor codes and based on the DatabaseProductNametaken from the DatabaseMetaData. The codes for the actual database you are using are used.

The SQLErrorCodeSQLExceptionTranslatorapplies matching rules in the following sequence:

[Note] Note

The SQLErrorCodesFactoryis used by default to define Error codes and custom exception translations. They are looked up in a file named sql-error-codes.xmlfrom the classpath and the matching SQLErrorCodesinstance is located based on the database name from the database metadata of the database in use.
  • Any custom translation implemented by a subclass. Normally the provided concrete SQLErrorCodeSQLExceptionTranslatoris used so this rule does not apply. It only applies if you have actually provided a subclass implementation.
  • Any custom implementation of the SQLExceptionTranslatorinterface that is provided as the customSqlExceptionTranslatorproperty of the SQLErrorCodesclass.
  • The list of instances of the CustomSQLErrorCodesTranslationclass, provided for the customTranslationsproperty of the SQLErrorCodesclass, are searched for a match.
  • Error code matching is applied.
  • Use the fallback translator. SQLExceptionSubclassTranslatoris the default fallback translator. If this translation is not available then the next fallback translator is the SQLStateSQLExceptionTranslator.

You can extend SQLErrorCodeSQLExceptionTranslator:

								public
								classCustomSQLErrorCodesTranslator
								extendsSQLErrorCodeSQLExceptionTranslator {
								protectedDataAccessException customTranslate(String task, String sql, SQLException sqlex) {
								if(sqlex.getErrorCode() == -
								12345) {
								return
								newDeadlockLoserDataAccessException(task, sqlex); }
								returnnull; } }

In this example, the specific error code -12345is translated and other errors are left to be translated by the default translator implementation. To use this custom translator, it is necessary to pass it to the JdbcTemplatethrough the method setExceptionTranslatorand to use this JdbcTemplatefor all of the data access processing where this translator is needed. Here is an example of how this custom translator can be used:

								privateJdbcTemplate jdbcTemplate;
								public
								voidsetDataSource(DataSource dataSource) {
								// create a JdbcTemplate and set data source
								this.jdbcTemplate =
								newJdbcTemplate();
								this.jdbcTemplate.setDataSource(dataSource);
								// create a custom translator and set the DataSource for the default translation lookupCustomSQLErrorCodesTranslator tr =
								newCustomSQLErrorCodesTranslator(); tr.setDataSource(dataSource);
								this.jdbcTemplate.setExceptionTranslator(tr); }
								public
								voidupdateShippingCharge(
								longorderId,
								longpct) {
								// use the prepared JdbcTemplate for this update
								this.jdbcTemplate.update(
								"update orders"+
								" set shipping_charge = shipping_charge * ? / 100"+
								" where id = ?", pct, orderId); }

The custom translator is passed a data source in order to look up the error codes in sql-error-codes.xml.

19.2.4 Executing statements

Executing an SQL statement requires very little code. You need a DataSourceand a JdbcTemplate, including the convenience methods that are provided with the JdbcTemplate. The following example shows what you need to include for a minimal but fully functional class that creates a new table:

								importjavax.sql.DataSource;
								importorg.springframework.jdbc.core.JdbcTemplate;
								public
								classExecuteAStatement {
								privateJdbcTemplate jdbcTemplate;
								public
								voidsetDataSource(DataSource dataSource) {
								this.jdbcTemplate =
								newJdbcTemplate(dataSource); }
								public
								voiddoExecute() {
								this.jdbcTemplate.execute(
								"create table mytable (id integer, name varchar(100))"); } }

19.2.5 Running queries

Some query methods return a single value. To retrieve a count or a specific value from one row, use queryForObject(..). The latter converts the returned JDBC Typeto the Java class that is passed in as an argument. If the type conversion is invalid, then an InvalidDataAccessApiUsageExceptionis thrown. Here is an example that contains two query methods, one for an intand one that queries for a String.

								importjavax.sql.DataSource;
								importorg.springframework.jdbc.core.JdbcTemplate;
								public
								classRunAQuery {
								privateJdbcTemplate jdbcTemplate;
								public
								voidsetDataSource(DataSource dataSource) {
								this.jdbcTemplate =
								newJdbcTemplate(dataSource); }
								public
								intgetCount() {
								return
								this.jdbcTemplate.queryForObject(
								"select count(*) from mytable", Integer.
								class); }
								publicString getName() {
								return
								this.jdbcTemplate.queryForObject(
								"select name from mytable", String.
								class); } }

In addition to the single result query methods, several methods return a list with an entry for each row that the query returned. The most generic method is queryForList(..)which returns a Listwhere each entry is a Mapwith each entry in the map representing the column value for that row. If you add a method to the above example to retrieve a list of all the rows, it would look like this:

								privateJdbcTemplate jdbcTemplate;
								public
								voidsetDataSource(DataSource dataSource) {
								this.jdbcTemplate =
								newJdbcTemplate(dataSource); }
								publicList<Map<String, Object>> getList() {
								return
								this.jdbcTemplate.queryForList(
								"select * from mytable"); }

The list returned would look something like this:

[{name=Bob, id=1}, {name=Mary, id=2}]

19.2.6 Updating the database

The following example shows a column updated for a certain primary key. In this example, an SQL statement has placeholders for row parameters. The parameter values can be passed in as varargs or alternatively as an array of objects. Thus primitives should be wrapped in the primitive wrapper classes explicitly or using auto-boxing.

								importjavax.sql.DataSource;
								importorg.springframework.jdbc.core.JdbcTemplate;
								public
								classExecuteAnUpdate {
								privateJdbcTemplate jdbcTemplate;
								public
								voidsetDataSource(DataSource dataSource) {
								this.jdbcTemplate =
								newJdbcTemplate(dataSource); }
								public
								voidsetName(
								intid, String name) {
								this.jdbcTemplate.update(
								"update mytable set name = ? where id = ?", name, id); } }

19.2.7 Retrieving auto-generated keys

An update()convenience method supports the retrieval of primary keys generated by the database. This support is part of the JDBC 3.0 standard; see Chapter 13.6 of the specification for details. The method takes a PreparedStatementCreatoras its first argument, and this is the way the required insert statement is specified. The other argument is a KeyHolder, which contains the generated key on successful return from the update. There is not a standard single way to create an appropriate PreparedStatement(which explains why the method signature is the way it is). The following example works on Oracle but may not work on other platforms:

								finalString INSERT_SQL =
								"insert into my_test (name) values(?)";
								finalString name =
								"Rob"; KeyHolder keyHolder =
								newGeneratedKeyHolder(); jdbcTemplate.update(
								newPreparedStatementCreator() {
								publicPreparedStatement createPreparedStatement(Connection connection)
								throwsSQLException { PreparedStatement ps = connection.prepareStatement(INSERT_SQL,
								newString[] {
								"id"}); ps.setString(
								1, name);
								returnps; } }, keyHolder);
								// keyHolder.getKey() now contains the generated key

19.3 Controlling database connections

19.3.1 DataSource

Spring obtains a connection to the database through a DataSource. A DataSourceis part of the JDBC specification and is a generalized connection factory. It allows a container or a framework to hide connection pooling and transaction management issues from the application code. As a developer, you need not know details about how to connect to the database; that is the responsibility of the administrator that sets up the datasource. You most likely fill both roles as you develop and test code, but you do not necessarily have to know how the production data source is configured.

When using Spring’s JDBC layer, you obtain a data source from JNDI or you configure your own with a connection pool implementation provided by a third party. Popular implementations are Apache Jakarta Commons DBCP and C3P0. Implementations in the Spring distribution are meant only for testing purposes and do not provide pooling.

This section uses Spring’s DriverManagerDataSourceimplementation, and several additional implementations are covered later.

[Note] Note

Only use the DriverManagerDataSourceclass should only be used for testing purposes since it does not provide pooling and will perform poorly when multiple requests for a connection are made.

You obtain a connection with DriverManagerDataSourceas you typically obtain a JDBC connection. Specify the fully qualified classname of the JDBC driver so that the DriverManagercan load the driver class. Next, provide a URL that varies between JDBC drivers. (Consult the documentation for your driver for the correct value.) Then provide a username and a password to connect to the database. Here is an example of how to configure a DriverManagerDataSourcein Java code:

DriverManagerDataSource dataSource =
								newDriverManagerDataSource(); dataSource.setDriverClassName(
								"org.hsqldb.jdbcDriver"); dataSource.setUrl(
								"jdbc:hsqldb:hsql://localhost:"); dataSource.setUsername(
								"sa"); dataSource.setPassword(
								"");

Here is the corresponding XML configuration:

<bean id=
								"dataSource"
								class=
								"org.springframework.jdbc.datasource.DriverManagerDataSource"> <property name=
								"driverClassName"value=
								"${jdbc.driverClassName}"/> <property name=
								"url"value=
								"${jdbc.url}"/> <property name=
								"username"value=
								"${jdbc.username}"/> <property name=
								"password"value=
								"${jdbc.password}"/> </bean> <context:property-placeholder location=
								"jdbc.properties"/>

The following examples show the basic connectivity and configuration for DBCP and C3P0. To learn about more options that help control the pooling features, see the product documentation for the respective connection pooling implementations.

DBCP configuration:

<bean id=
								"dataSource"
								class=
								"org.apache.commons.dbcp.BasicDataSource"destroy-method=
								"close"> <property name=
								"driverClassName"value=
								"${jdbc.driverClassName}"/> <property name=
								"url"value=
								"${jdbc.url}"/> <property name=
								"username"value=
								"${jdbc.username}"/> <property name=
								"password"value=
								"${jdbc.password}"/> </bean> <context:property-placeholder location=
								"jdbc.properties"/>

C3P0 configuration:

<bean id=
								"dataSource"
								class=
								"com.mchange.v2.c3p0.ComboPooledDataSource"destroy-method=
								"close"> <property name=
								"driverClass"value=
								"${jdbc.driverClassName}"/> <property name=
								"jdbcUrl"value=
								"${jdbc.url}"/> <property name=
								"user"value=
								"${jdbc.username}"/> <property name=
								"password"value=
								"${jdbc.password}"/> </bean> <context:property-placeholder location=
								"jdbc.properties"/>

19.3.2 DataSourceUtils

The DataSourceUtilsclass is a convenient and powerful helper class that provides staticmethods to obtain connections from JNDI and close connections if necessary. It supports thread-bound connections with, for example, DataSourceTransactionManager.

19.3.3 SmartDataSource

The SmartDataSourceinterface should be implemented by classes that can provide a connection to a relational database. It extends the DataSourceinterface to allow classes using it to query whether the connection should be closed after a given operation. This usage is efficient when you know that you will reuse a connection.

19.3.4 AbstractDataSource

AbstractDataSourceis an abstractbase class for Spring’s DataSourceimplementations that implements code that is common to all DataSourceimplementations. You extend the AbstractDataSourceclass if you are writing your own DataSourceimplementation.

19.3.5 SingleConnectionDataSource

The SingleConnectionDataSourceclass is an implementation of the SmartDataSourceinterface that wraps a single Connectionthat is notclosed after each use. Obviously, this is not multi-threading capable.

If any client code calls closein the assumption of a pooled connection, as when using persistence tools, set the suppressCloseproperty to true. This setting returns a close-suppressing proxy wrapping the physical connection. Be aware that you will not be able to cast this to a native Oracle Connectionor the like anymore.

This is primarily a test class. For example, it enables easy testing of code outside an application server, in conjunction with a simple JNDI environment. In contrast to DriverManagerDataSource, it reuses the same connection all the time, avoiding excessive creation of physical connections.

19.3.6 DriverManagerDataSource

The DriverManagerDataSourceclass is an implementation of the standard DataSourceinterface that configures a plain JDBC driver through bean properties, and returns a new Connectionevery time.

This implementation is useful for test and stand-alone environments outside of a Java EE container, either as a DataSourcebean in a Spring IoC container, or in conjunction with a simple JNDI environment. Pool-assuming Connection.close()calls will simply close the connection, so any DataSource-aware persistence code should work. However, using JavaBean-style connection pools such as commons-dbcpis so easy, even in a test environment, that it is almost always preferable to use such a connection pool over DriverManagerDataSource.

19.3.7 TransactionAwareDataSourceProxy

TransactionAwareDataSourceProxyis a proxy for a target DataSource, which wraps that target DataSourceto add awareness of Spring-managed transactions. In this respect, it is similar to a transactional JNDI DataSourceas provided by a Java EE server.

[Note] Note

It is rarely desirable to use this class, except when already existing code that must be called and passed a standard JDBC DataSourceinterface implementation. In this case, it’s possible to still have this code be usable, and at the same time have this code participating in Spring managed transactions. It is generally preferable to write your own new code using the higher level abstractions for resource management, such as JdbcTemplateor DataSourceUtils.

(See the TransactionAwareDataSourceProxyjavadocs for more details.)

19.3.8 DataSourceTransactionManager

The DataSourceTransactionManagerclass is a PlatformTransactionManagerimplementation for single JDBC datasources. It binds a JDBC connection from the specified data source to the currently executing thread, potentially allowing for one thread connection per data source.

Application code is required to retrieve the JDBC connection through DataSourceUtils.getConnection(DataSource)instead of Java EE’s standard DataSource.getConnection. It throws unchecked org.springframework.daoexceptions instead of checked SQLExceptions. All framework classes like JdbcTemplateuse this strategy implicitly. If not used with this transaction manager, the lookup strategy behaves exactly like the common one - it can thus be used in any case.

The DataSourceTransactionManagerclass supports custom isolation levels, and timeouts that get applied as appropriate JDBC statement query timeouts. To support the latter, application code must either use JdbcTemplateor call the DataSourceUtils.applyTransactionTimeout(..)method for each created statement.

This implementation can be used instead of JtaTransactionManagerin the single resource case, as it does not require the container to support JTA. Switching between both is just a matter of configuration, if you stick to the required connection lookup pattern. JTA does not support custom isolation levels!

19.3.9 NativeJdbcExtractor

Sometimes you need to access vendor specific JDBC methods that differ from the standard JDBC API. This can be problematic if you are running in an application server or with a DataSourcethat wraps the Connection, Statementand ResultSetobjects with its own wrapper objects. To gain access to the native objects you can configure your JdbcTemplateor OracleLobHandlerwith a NativeJdbcExtractor.

The NativeJdbcExtractorcomes in a variety of flavors to match your execution environment:

  • SimpleNativeJdbcExtractor
  • C3P0NativeJdbcExtractor
  • CommonsDbcpNativeJdbcExtractor
  • JBossNativeJdbcExtractor
  • WebLogicNativeJdbcExtractor
  • WebSphereNativeJdbcExtractor
  • XAPoolNativeJdbcExtractor

Usually the SimpleNativeJdbcExtractoris sufficient for unwrapping a Connectionobject in most environments. See the javadocs for more details.

19.4 JDBC batch operations

Most JDBC drivers provide improved performance if you batch multiple calls to the same prepared statement. By grouping updates into batches you limit the number of round trips to the database.

19.4.1 Basic batch operations with the JdbcTemplate

You accomplish JdbcTemplatebatch processing by implementing two methods of a special interface, BatchPreparedStatementSetter, and passing that in as the second parameter in your batchUpdatemethod call. Use the getBatchSizemethod to provide the size of the current batch. Use the setValuesmethod to set the values for the parameters of the prepared statement. This method will be called the number of times that you specified in the getBatchSizecall. The following example updates the actor table based on entries in a list. The entire list is used as the batch in this example:

								public
								classJdbcActorDao
								implementsActorDao {
								privateJdbcTemplate jdbcTemplate;
								public
								voidsetDataSource(DataSource dataSource) {
								this.jdbcTemplate =
								newJdbcTemplate(dataSource); }
								public
								int[] batchUpdate(
								finalList<Actor> actors) {
								int[] updateCounts = jdbcTemplate.batchUpdate(
								"update t_actor set first_name = ?, "+
								"last_name = ? where id = ?",
								newBatchPreparedStatementSetter() {
								public
								voidsetValues(PreparedStatement ps,
								inti)
								throwsSQLException { ps.setString(
								1, actors.get(i).getFirstName()); ps.setString(
								2, actors.get(i).getLastName()); ps.setLong(
								3, actors.get(i).getId().longValue()); }
								public
								intgetBatchSize() {
								returnactors.size(); } });
								returnupdateCounts; }
								// ... additional methods}

If you are processing a stream of updates or reading from a file, then you might have a preferred batch size, but the last batch might not have that number of entries. In this case you can use the InterruptibleBatchPreparedStatementSetterinterface, which allows you to interrupt a batch once the input source is exhausted. The isBatchExhaustedmethod allows you to signal the end of the batch.

19.4.2 Batch operations with a List of objects

Both the JdbcTemplateand the NamedParameterJdbcTemplateprovides an alternate way of providing the batch update. Instead of implementing a special batch interface, you provide all parameter values in the call as a list. The framework loops over these values and uses an internal prepared statement setter. The API varies depending on whether you use named parameters. For the named parameters you provide an array of SqlParameterSource, one entry for each member of the batch. You can use the SqlParameterSource.createBatchmethod to create this array, passing in either an array of JavaBeans or an array of Maps containing the parameter values.

This example shows a batch update using named parameters:

								public
								classJdbcActorDao
								implementsActorDao {
								privateNamedParameterTemplate namedParameterJdbcTemplate;
								public
								voidsetDataSource(DataSource dataSource) {
								this.namedParameterJdbcTemplate =
								newNamedParameterJdbcTemplate(dataSource); }
								public
								int[] batchUpdate(
								finalList<Actor> actors) { SqlParameterSource[] batch = SqlParameterSourceUtils.createBatch(actors.toArray());
								int[] updateCounts = namedParameterJdbcTemplate.batchUpdate(
								"update t_actor set first_name = :firstName, last_name = :lastName where id = :id", batch);
								returnupdateCounts; }
								// ... additional methods}

For an SQL statement using the classic "?" placeholders, you pass in a list containing an object array with the update values. This object array must have one entry for each placeholder in the SQL statement, and they must be in the same order as they are defined in the SQL statement.

The same example using classic JDBC "?" placeholders:

								public
								classJdbcActorDao
								implementsActorDao {
								privateJdbcTemplate jdbcTemplate;
								public
								voidsetDataSource(DataSource dataSource) {
								this.jdbcTemplate =
								newJdbcTemplate(dataSource); }
								public
								int[] batchUpdate(
								finalList<Actor> actors) { List<Object[]> batch =
								newArrayList<Object[]>();
								for(Actor actor : actors) { Object[] values =
								newObject[] { actor.getFirstName(), actor.getLastName(), actor.getId()}; batch.add(values); }
								int[] updateCounts = jdbcTemplate.batchUpdate(
								"update t_actor set first_name = ?, last_name = ? where id = ?", batch);
								returnupdateCounts; }
								// ... additional methods}

All of the above batch update methods return an int array containing the number of affected rows for each batch entry. This count is reported by the JDBC driver. If the count is not available, the JDBC driver returns a -2 value.

19.4.3 Batch operations with multiple batches

The last example of a batch update deals with batches that are so large that you want to break them up into several smaller batches. You can of course do this with the methods mentioned above by making multiple calls to the batchUpdatemethod, but there is now a more convenient method. This method takes, in addition to the SQL statement, a Collection of objects containing the parameters, the number of updates to make for each batch and a ParameterizedPreparedStatementSetterto set the values for the parameters of the prepared statement. The framework loops over the provided values and breaks the update calls into batches of the size specified.

This example shows a batch update using a batch size of 100:

								public
								classJdbcActorDao
								implementsActorDao {
								privateJdbcTemplate jdbcTemplate;
								public
								voidsetDataSource(DataSource dataSource) {
								this.jdbcTemplate =
								newJdbcTemplate(dataSource); }
								public
								int[][] batchUpdate(
								finalCollection<Actor> actors) {
								int[][] updateCounts = jdbcTemplate.batchUpdate(
								"update t_actor set first_name = ?, last_name = ? where id = ?", actors,
								100,
								newParameterizedPreparedStatementSetter<Actor>() {
								public
								voidsetValues(PreparedStatement ps, Actor argument)
								throwsSQLException { ps.setString(
								1, argument.getFirstName()); ps.setString(
								2, argument.getLastName()); ps.setLong(
								3, argument.getId().longValue()); } });
								returnupdateCounts; }
								// ... additional methods}

The batch update methods for this call returns an array of int arrays containing an array entry for each batch with an array of the number of affected rows for each update. The top level array’s length indicates the number of batches executed and the second level array’s length indicates the number of updates in that batch. The number of updates in each batch should be the batch size provided for all batches except for the last one that might be less, depending on the total number of update objects provided. The update count for each update statement is the one reported by the JDBC driver. If the count is not available, the JDBC driver returns a -2 value.

19.5 Simplifying JDBC operations with the SimpleJdbc classes

The SimpleJdbcInsertand SimpleJdbcCallclasses provide a simplified configuration by taking advantage of database metadata that can be retrieved through the JDBC driver. This means there is less to configure up front, although you can override or turn off the metadata processing if you prefer to provide all the details in your code.

19.5.1 Inserting data using SimpleJdbcInsert

Let’s start by looking at the SimpleJdbcInsertclass with the minimal amount of configuration options. You should instantiate the SimpleJdbcInsertin the data access layer’s initialization method. For this example, the initializing method is the setDataSourcemethod. You do not need to subclass the SimpleJdbcInsertclass; simply create a new instance and set the table name using the withTableNamemethod. Configuration methods for this class follow the "fluid" style that returns the instance of the SimpleJdbcInsert, which allows you to chain all configuration methods. This example uses only one configuration method; you will see examples of multiple ones later.

								public
								classJdbcActorDao
								implementsActorDao {
								privateJdbcTemplate jdbcTemplate;
								privateSimpleJdbcInsert insertActor;
								public
								voidsetDataSource(DataSource dataSource) {
								this.jdbcTemplate =
								newJdbcTemplate(dataSource);
								this.insertActor =
								newSimpleJdbcInsert(dataSource).withTableName(
								"t_actor"); }
								public
								voidadd(Actor actor) { Map<String, Object> parameters =
								newHashMap<String, Object>(
								3); parameters.put(
								"id", actor.getId()); parameters.put(
								"first_name", actor.getFirstName()); parameters.put(
								"last_name", actor.getLastName()); insertActor.execute(parameters); }
								// ... additional methods}

The execute method used here takes a plain java.utils.Mapas its only parameter. The important thing to note here is that the keys used for the Map must match the column names of the table as defined in the database. This is because we read the metadata in order to construct the actual insert statement.

19.5.2 Retrieving auto-generated keys using SimpleJdbcInsert

This example uses the same insert as the preceding, but instead of passing in the id it retrieves the auto-generated key and sets it on the new Actor object. When you create the SimpleJdbcInsert, in addition to specifying the table name, you specify the name of the generated key column with the usingGeneratedKeyColumnsmethod.

								public
								classJdbcActorDao
								implementsActorDao {
								privateJdbcTemplate jdbcTemplate;
								privateSimpleJdbcInsert insertActor;
								public
								voidsetDataSource(DataSource dataSource) {
								this.jdbcTemplate =
								newJdbcTemplate(dataSource);
								this.insertActor =
								newSimpleJdbcInsert(dataSource) .withTableName(
								"t_actor") .usingGeneratedKeyColumns(
								"id"); }
								public
								voidadd(Actor actor) { Map<String, Object> parameters =
								newHashMap<String, Object>(
								2); parameters.put(
								"first_name", actor.getFirstName()); parameters.put(
								"last_name", actor.getLastName()); Number newId = insertActor.executeAndReturnKey(parameters); actor.setId(newId.longValue()); }
								// ... additional methods}

The main difference when executing the insert by this second approach is that you do not add the id to the Map and you call the executeAndReturnKeymethod. This returns a java.lang.Numberobject with which you can create an instance of the numerical type that is used in our domain class. You cannot rely on all databases to return a specific Java class here; java.lang.Numberis the base class that you can rely on. If you have multiple auto-generated columns, or the generated values are non-numeric, then you can use a KeyHolderthat is returned from the executeAndReturnKeyHoldermethod.

19.5.3 Specifying columns for a SimpleJdbcInsert

You can limit the columns for an insert by specifying a list of column names with the usingColumnsmethod:

								public
								classJdbcActorDao
								implementsActorDao {
								privateJdbcTemplate jdbcTemplate;
								privateSimpleJdbcInsert insertActor;
								public
								voidsetDataSource(DataSource dataSource) {
								this.jdbcTemplate =
								newJdbcTemplate(dataSource);
								this.insertActor =
								newSimpleJdbcInsert(dataSource) .withTableName(
								"t_actor") .usingColumns(
								"first_name",
								"last_name") .usingGeneratedKeyColumns(
								"id"); }
								public
								voidadd(Actor actor) { Map<String, Object> parameters =
								newHashMap<String, Object>(
								2); parameters.put(
								"first_name", actor.getFirstName()); parameters.put(
								"last_name", actor.getLastName()); Number newId = insertActor.executeAndReturnKey(parameters); actor.setId(newId.longValue()); }
								// ... additional methods}

The execution of the insert is the same as if you had relied on the metadata to determine which columns to use.

19.5.4 Using SqlParameterSource to provide parameter values

Using a Mapto provide parameter values works fine, but it’s not the most convenient class to use. Spring provides a couple of implementations of the SqlParameterSourceinterface that can be used instead.The first one is BeanPropertySqlParameterSource, which is a very convenient class if you have a JavaBean-compliant class that contains your values. It will use the corresponding getter method to extract the parameter values. Here is an example:

								public
								classJdbcActorDao
								implementsActorDao {
								privateJdbcTemplate jdbcTemplate;
								privateSimpleJdbcInsert insertActor;
								public
								voidsetDataSource(DataSource dataSource) {
								this.jdbcTemplate =
								newJdbcTemplate(dataSource);
								this.insertActor =
								newSimpleJdbcInsert(dataSource) .withTableName(
								"t_actor") .usingGeneratedKeyColumns(
								"id"); }
								public
								voidadd(Actor actor) { SqlParameterSource parameters =
								newBeanPropertySqlParameterSource(actor); Number newId = insertActor.executeAndReturnKey(parameters); actor.setId(newId.longValue()); }
								// ... additional methods}

Another option is the MapSqlParameterSourcethat resembles a Map but provides a more convenient addValuemethod that can be chained.

								public
								classJdbcActorDao
								implementsActorDao {
								privateJdbcTemplate jdbcTemplate;
								privateSimpleJdbcInsert insertActor;
								public
								voidsetDataSource(DataSource dataSource) {
								this.jdbcTemplate =
								newJdbcTemplate(dataSource);
								this.insertActor =
								newSimpleJdbcInsert(dataSource) .withTableName(
								"t_actor") .usingGeneratedKeyColumns(
								"id"); }
								public
								voidadd(Actor actor) { SqlParameterSource parameters =
								newMapSqlParameterSource() .addValue(
								"first_name", actor.getFirstName()) .addValue(
								"last_name", actor.getLastName()); Number newId = insertActor.executeAndReturnKey(parameters); actor.setId(newId.longValue()); }
								// ... additional methods}

As you can see, the configuration is the same; only the executing code has to change to use these alternative input classes.

19.5.5 Calling a stored procedure with SimpleJdbcCall

The SimpleJdbcCallclass leverages metadata in the database to look up names of inand outparameters, so that you do not have to declare them explicitly. You can declare parameters if you prefer to do that, or if you have parameters such as ARRAYor STRUCTthat do not have an automatic mapping to a Java class. The first example shows a simple procedure that returns only scalar values in VARCHARand DATEformat from a MySQL database. The example procedure reads a specified actor entry and returns first_name, last_name, and birth_datecolumns in the form of outparameters.

								CREATE
								PROCEDUREread_actor (
								INin_id
								INTEGER,
								OUTout_first_name
								VARCHAR(
								100),
								OUTout_last_name
								VARCHAR(
								100),
								OUTout_birth_date
								DATE)
								BEGIN
								SELECTfirst_name, last_name, birth_date
								INTOout_first_name, out_last_name, out_birth_date
								FROMt_actor
								whereid = in_id;
								END;

The in_idparameter contains the idof the actor you are looking up. The outparameters return the data read from the table.

The SimpleJdbcCallis declared in a similar manner to the SimpleJdbcInsert. You should instantiate and configure the class in the initialization method of your data access layer. Compared to the StoredProcedure class, you don’t have to create a subclass and you don’t have to declare parameters that can be looked up in the database metadata. Following is an example of a SimpleJdbcCall configuration using the above stored procedure. The only configuration option, in addition to the DataSource, is the name of the stored procedure.

								public
								classJdbcActorDao
								implementsActorDao {
								privateJdbcTemplate jdbcTemplate;
								privateSimpleJdbcCall procReadActor;
								public
								voidsetDataSource(DataSource dataSource) {
								this.jdbcTemplate =
								newJdbcTemplate(dataSource);
								this.procReadActor =
								newSimpleJdbcCall(dataSource) .withProcedureName(
								"read_actor"); }
								publicActor readActor(Long id) { SqlParameterSource in =
								newMapSqlParameterSource() .addValue(
								"in_id", id); Map out = procReadActor.execute(in); Actor actor =
								newActor(); actor.setId(id); actor.setFirstName((String) out.get(
								"out_first_name")); actor.setLastName((String) out.get(
								"out_last_name")); actor.setBirthDate((Date) out.get(
								"out_birth_date"));
								returnactor; }
								// ... additional methods}

The code you write for the execution of the call involves creating an SqlParameterSourcecontaining the IN parameter. It’s important to match the name provided for the input value with that of the parameter name declared in the stored procedure. The case does not have to match because you use metadata to determine how database objects should be referred to in a stored procedure. What is specified in the source for the stored procedure is not necessarily the way it is stored in the database. Some databases transform names to all upper case while others use lower case or use the case as specified.

The executemethod takes the IN parameters and returns a Map containing any outparameters keyed by the name as specified in the stored procedure. In this case they are out_first_name, out_last_nameand out_birth_date.

The last part of the executemethod creates an Actor instance to use to return the data retrieved. Again, it is important to use the names of the outparameters as they are declared in the stored procedure. Also, the case in the names of the outparameters stored in the results map matches that of the outparameter names in the database, which could vary between databases. To make your code more portable you should do a case-insensitive lookup or instruct Spring to use a LinkedCaseInsensitiveMap. To do the latter, you create your own JdbcTemplateand set the setResultsMapCaseInsensitiveproperty to true. Then you pass this customized JdbcTemplateinstance into the constructor of your SimpleJdbcCall. Here is an example of this configuration:

								public
								classJdbcActorDao
								implementsActorDao {
								privateSimpleJdbcCall procReadActor;
								public
								voidsetDataSource(DataSource dataSource) { JdbcTemplate jdbcTemplate =
								newJdbcTemplate(dataSource); jdbcTemplate.setResultsMapCaseInsensitive(true);
								this.procReadActor =
								newSimpleJdbcCall(jdbcTemplate) .withProcedureName(
								"read_actor"); }
								// ... additional methods}

By taking this action, you avoid conflicts in the case used for the names of your returned outparameters.

19.5.6 Explicitly declaring parameters to use for a SimpleJdbcCall

You have seen how the parameters are deduced based on metadata, but you can declare then explicitly if you wish. You do this by creating and configuring SimpleJdbcCallwith the declareParametersmethod, which takes a variable number of SqlParameterobjects as input. See the next section for details on how to define an SqlParameter.

[Note] Note

Explicit declarations are necessary if the database you use is not a Spring-supported database. Currently Spring supports metadata lookup of stored procedure calls for the following databases: Apache Derby, DB2, MySQL, Microsoft SQL Server, Oracle, and Sybase. We also support metadata lookup of stored functions for MySQL, Microsoft SQL Server, and Oracle.

You can opt to declare one, some, or all the parameters explicitly. The parameter metadata is still used where you do not declare parameters explicitly. To bypass all processing of metadata lookups for potential parameters and only use the declared parameters, you call the method withoutProcedureColumnMetaDataAccessas part of the declaration. Suppose that you have two or more different call signatures declared for a database function. In this case you call the useInParameterNamesto specify the list of IN parameter names to include for a given signature.

The following example shows a fully declared procedure call, using the information from the preceding example.

								public
								classJdbcActorDao
								implementsActorDao {
								privateSimpleJdbcCall procReadActor;
								public
								voidsetDataSource(DataSource dataSource) { JdbcTemplate jdbcTemplate =
								newJdbcTemplate(dataSource); jdbcTemplate.setResultsMapCaseInsensitive(true);
								this.procReadActor =
								newSimpleJdbcCall(jdbcTemplate) .withProcedureName(
								"read_actor") .withoutProcedureColumnMetaDataAccess() .useInParameterNames(
								"in_id") .declareParameters(
								newSqlParameter(
								"in_id", Types.NUMERIC),
								newSqlOutParameter(
								"out_first_name", Types.VARCHAR),
								newSqlOutParameter(
								"out_last_name", Types.VARCHAR),
								newSqlOutParameter(
								"out_birth_date", Types.DATE) ); }
								// ... additional methods}

The execution and end results of the two examples are the same; this one specifies all details explicitly rather than relying on metadata.

19.5.7 How to define SqlParameters

To define a parameter for the SimpleJdbc classes and also for the RDBMS operations classes, covered in Section 19.6, “Modeling JDBC operations as Java objects”, you use an SqlParameteror one of its subclasses. You typically specify the parameter name and SQL type in the constructor. The SQL type is specified using the java.sql.Typesconstants. We have already seen declarations like:

								newSqlParameter(
								"in_id", Types.NUMERIC),
								newSqlOutParameter(
								"out_first_name", Types.VARCHAR),

The first line with the SqlParameterdeclares an IN parameter. IN parameters can be used for both stored procedure calls and for queries using the SqlQueryand its subclasses covered in the following section.

The second line with the SqlOutParameterdeclares an outparameter to be used in a stored procedure call. There is also an SqlInOutParameterfor InOutparameters, parameters that provide an INvalue to the procedure and that also return a value.

[Note] Note

Only parameters declared as SqlParameterand SqlInOutParameterwill be used to provide input values. This is different from the StoredProcedureclass, which for backwards compatibility reasons allows input values to be provided for parameters declared as SqlOutParameter.

For IN parameters, in addition to the name and the SQL type, you can specify a scale for numeric data or a type name for custom database types. For outparameters, you can provide a RowMapperto handle mapping of rows returned from a REFcursor. Another option is to specify an SqlReturnTypethat provides an opportunity to define customized handling of the return values.

19.5.8 Calling a stored function using SimpleJdbcCall

You call a stored function in almost the same way as you call a stored procedure, except that you provide a function name rather than a procedure name. You use the withFunctionNamemethod as part of the configuration to indicate that we want to make a call to a function, and the corresponding string for a function call is generated. A specialized execute call, executeFunction,is used to execute the function and it returns the function return value as an object of a specified type, which means you do not have to retrieve the return value from the results map. A similar convenience method named executeObjectis also available for stored procedures that only have one outparameter. The following example is based on a stored function named get_actor_namethat returns an actor’s full name. Here is the MySQL source for this function:

								CREATE
								FUNCTIONget_actor_name (in_id
								INTEGER)
								RETURNS
								VARCHAR(
								200)
								READS
								SQL
								DATA
								BEGIN
								DECLAREout_name
								VARCHAR(
								200);
								SELECTconcat(first_name,
								' ', last_name)
								INTOout_name
								FROMt_actor
								whereid = in_id;
								RETURNout_name;
								END;

To call this function we again create a SimpleJdbcCallin the initialization method.

								public
								classJdbcActorDao
								implementsActorDao {
								privateJdbcTemplate jdbcTemplate;
								privateSimpleJdbcCall funcGetActorName;
								public
								voidsetDataSource(DataSource dataSource) {
								this.jdbcTemplate =
								newJdbcTemplate(dataSource); JdbcTemplate jdbcTemplate =
								newJdbcTemplate(dataSource); jdbcTemplate.setResultsMapCaseInsensitive(true);
								this.funcGetActorName =
								newSimpleJdbcCall(jdbcTemplate) .withFunctionName(
								"get_actor_name"); }
								publicString getActorName(Long id) { SqlParameterSource in =
								newMapSqlParameterSource() .addValue(
								"in_id", id); String name = funcGetActorName.executeFunction(String.
								class, in);
								returnname; }
								// ... additional methods}

The execute method used returns a Stringcontaining the return value from the function call.

19.5.9 Returning ResultSet/REF Cursor from a SimpleJdbcCall

Calling a stored procedure or function that returns a result set is a bit tricky. Some databases return result sets during the JDBC results processing while others require an explicitly registered outparameter of a specific type. Both approaches need additional processing to loop over the result set and process the returned rows. With the SimpleJdbcCallyou use the returningResultSetmethod and declare a RowMapperimplementation to be used for a specific parameter. In the case where the result set is returned during the results processing, there are no names defined, so the returned results will have to match the order in which you declare the RowMapperimplementations. The name specified is still used to store the processed list of results in the results map that is returned from the execute statement.

The next example uses a stored procedure that takes no IN parameters and returns all rows from the t_actor table. Here is the MySQL source for this procedure:

								CREATE
								PROCEDUREread_all_actors()
								BEGIN
								SELECT
								a.id,
								a.first_name,
								a.last_name,
								a.birth_date
								FROMt_actor
								a;
								END;

To call this procedure you declare the RowMapper. Because the class you want to map to follows the JavaBean rules, you can use a BeanPropertyRowMapperthat is created by passing in the required class to map to in the newInstancemethod.

								public
								classJdbcActorDao
								implementsActorDao {
								privateSimpleJdbcCall procReadAllActors;
								public
								voidsetDataSource(DataSource dataSource) { JdbcTemplate jdbcTemplate =
								newJdbcTemplate(dataSource); jdbcTemplate.setResultsMapCaseInsensitive(true);
								this.procReadAllActors =
								newSimpleJdbcCall(jdbcTemplate) .withProcedureName(
								"read_all_actors") .returningResultSet(
								"actors", BeanPropertyRowMapper.newInstance(Actor.
								class)); }
								publicList getActorsList() { Map m = procReadAllActors.execute(
								newHashMap<String, Object>(
								0));
								return(List) m.get(
								"actors"); }
								// ... additional methods}

The execute call passes in an empty Map because this call does not take any parameters. The list of Actors is then retrieved from the results map and returned to the caller.

19.6 Modeling JDBC operations as Java objects

The org.springframework.jdbc.objectpackage contains classes that allow you to access the database in a more object-oriented manner. As an example, you can execute queries and get the results back as a list containing business objects with the relational column data mapped to the properties of the business object. You can also execute stored procedures and run update, delete, and insert statements.

[Note] Note

Many Spring developers believe that the various RDBMS operation classes described below (with the exception of the StoredProcedureclass) can often be replaced with straight JdbcTemplatecalls. Often it is simpler to write a DAO method that simply calls a method on a JdbcTemplatedirectly (as opposed to encapsulating a query as a full-blown class).

However, if you are getting measurable value from using the RDBMS operation classes, continue using these classes.

19.6.1 SqlQuery

SqlQueryis a reusable, threadsafe class that encapsulates an SQL query. Subclasses must implement the newRowMapper(..)method to provide a RowMapperinstance that can create one object per row obtained from iterating over the ResultSetthat is created during the execution of the query. The SqlQueryclass is rarely used directly because the MappingSqlQuerysubclass provides a much more convenient implementation for mapping rows to Java classes. Other implementations that extend SqlQueryare MappingSqlQueryWithParametersand UpdatableSqlQuery.

19.6.2 MappingSqlQuery

MappingSqlQueryis a reusable query in which concrete subclasses must implement the abstract mapRow(..)method to convert each row of the supplied ResultSetinto an object of the type specified. The following example shows a custom query that maps the data from the t_actorrelation to an instance of the Actorclass.

								public
								classActorMappingQuery
								extendsMappingSqlQuery<Actor> {
								publicActorMappingQuery(DataSource ds) {
								super(ds,
								"select id, first_name, last_name from t_actor where id = ?");
								super.declareParameter(
								newSqlParameter(
								"id", Types.INTEGER)); compile(); }
								
									@Override
								protectedActor mapRow(ResultSet rs,
								introwNumber)
								throwsSQLException { Actor actor =
								newActor(); actor.setId(rs.getLong(
								"id")); actor.setFirstName(rs.getString(
								"first_name")); actor.setLastName(rs.getString(
								"last_name"));
								returnactor; } }

The class extends MappingSqlQueryparameterized with the Actortype. The constructor for this customer query takes the DataSourceas the only parameter. In this constructor you call the constructor on the superclass with the DataSourceand the SQL that should be executed to retrieve the rows for this query. This SQL will be used to create a PreparedStatementso it may contain place holders for any parameters to be passed in during execution.You must declare each parameter using the declareParametermethod passing in an SqlParameter. The SqlParametertakes a name and the JDBC type as defined in java.sql.Types. After you define all parameters, you call the compile()method so the statement can be prepared and later executed. This class is thread-safe after it is compiled, so as long as these instances are created when the DAO is initialized they can be kept as instance variables and be reused.

								privateActorMappingQuery actorMappingQuery;
								
									@Autowired
								public
								voidsetDataSource(DataSource dataSource) {
								this.actorMappingQuery =
								newActorMappingQuery(dataSource); }
								publicCustomer getCustomer(Long id) {
								returnactorMappingQuery.findObject(id); }

The method in this example retrieves the customer with the id that is passed in as the only parameter. Since we only want one object returned we simply call the convenience method findObjectwith the id as parameter. If we had instead a query that returned a list of objects and took additional parameters then we would use one of the execute methods that takes an array of parameter values passed in as varargs.

								publicList<Actor> searchForActors(
								intage, String namePattern) { List<Actor> actors = actorSearchMappingQuery.execute(age, namePattern);
								returnactors; }

19.6.3 SqlUpdate

The SqlUpdateclass encapsulates an SQL update. Like a query, an update object is reusable, and like all RdbmsOperationclasses, an update can have parameters and is defined in SQL. This class provides a number of update(..)methods analogous to the execute(..)methods of query objects. The SQLUpdateclass is concrete. It can be subclassed, for example, to add a custom update method, as in the following snippet where it’s simply called execute. However, you don’t have to subclass the SqlUpdateclass since it can easily be parameterized by setting SQL and declaring parameters.

								importjava.sql.Types;
								importjavax.sql.DataSource;
								importorg.springframework.jdbc.core.SqlParameter;
								importorg.springframework.jdbc.object.SqlUpdate;
								public
								classUpdateCreditRating
								extendsSqlUpdate {
								publicUpdateCreditRating(DataSource ds) { setDataSource(ds); setSql(
								"update customer set credit_rating = ? where id = ?"); declareParameter(
								newSqlParameter(
								"creditRating", Types.NUMERIC)); declareParameter(
								newSqlParameter(
								"id", Types.NUMERIC)); compile(); }
								/** * @param id for the Customer to be updated * @param rating the new value for credit rating * @return number of rows updated */
								public
								intexecute(
								intid,
								intrating) {
								returnupdate(rating, id); } }

19.6.4 StoredProcedure

The StoredProcedureclass is a superclass for object abstractions of RDBMS stored procedures. This class is abstract, and its various execute(..)methods have protectedaccess, preventing use other than through a subclass that offers tighter typing.

The inherited sqlproperty will be the name of the stored procedure in the RDBMS.

To define a parameter for the StoredProcedureclass, you use an SqlParameteror one of its subclasses. You must specify the parameter name and SQL type in the constructor like in the following code snippet. The SQL type is specified using the java.sql.Typesconstants.

								newSqlParameter(
								"in_id", Types.NUMERIC),
								newSqlOutParameter(
								"out_first_name", Types.VARCHAR),

The first line with the SqlParameterdeclares an IN parameter. IN parameters can be used for both stored procedure calls and for queries using the SqlQueryand its subclasses covered in the following section.

The second line with the SqlOutParameterdeclares an outparameter to be used in the stored procedure call. There is also an SqlInOutParameterfor I nOutparameters, parameters that provide an invalue to the procedure and that also return a value.

For i nparameters, in addition to the name and the SQL type, you can specify a scale for numeric data or a type name for custom database types. For outparameters you can provide a RowMapperto handle mapping of rows returned from a REF cursor. Another option is to specify an SqlReturnTypethat enables you to define customized handling of the return values.

Here is an example of a simple DAO that uses a StoredProcedureto call a function, sysdate(),which comes with any Oracle database. To use the stored procedure functionality you have to create a class that extends StoredProcedure. In this example, the StoredProcedureclass is an inner class, but if you need to reuse the StoredProcedureyou declare it as a top-level class. This example has no input parameters, but an output parameter is declared as a date type using the class SqlOutParameter. The execute()method executes the procedure and extracts the returned date from the results Map. The results Maphas an entry for each declared output parameter, in this case only one, using the parameter name as the key.

								importjava.sql.Types;
								importjava.util.Date;
								importjava.util.HashMap;
								importjava.util.Map;
								importjavax.sql.DataSource;
								importorg.springframework.beans.factory.annotation.Autowired;
								importorg.springframework.jdbc.core.SqlOutParameter;
								importorg.springframework.jdbc.object.StoredProcedure;
								public
								classStoredProcedureDao {
								privateGetSysdateProcedure getSysdate;
								
									@Autowired
								public
								voidinit(DataSource dataSource) {
								this.getSysdate =
								newGetSysdateProcedure(dataSource); }
								publicDate getSysdate() {
								returngetSysdate.execute(); }
								private
								classGetSysdateProcedure
								extendsStoredProcedure {
								private
								static
								finalString SQL =
								"sysdate";
								publicGetSysdateProcedure(DataSource dataSource) { setDataSource(dataSource); setFunction(true); setSql(SQL); declareParameter(
								newSqlOutParameter(
								"date", Types.DATE)); compile(); }
								publicDate execute() {
								// the 'sysdate' sproc has no input parameters, so an empty Map is supplied...Map<String, Object> results = execute(
								newHashMap<String, Object>()); Date sysdate = (Date) results.get(
								"date");
								returnsysdate; } } }

The following example of a StoredProcedurehas two output parameters (in this case, Oracle REF cursors).

								importoracle.jdbc.OracleTypes;
								importorg.springframework.jdbc.core.SqlOutParameter;
								importorg.springframework.jdbc.object.StoredProcedure;
								importjavax.sql.DataSource;
								importjava.util.HashMap;
								importjava.util.Map;
								public
								classTitlesAndGenresStoredProcedure
								extendsStoredProcedure {
								private
								static
								finalString SPROC_NAME =
								"AllTitlesAndGenres";
								publicTitlesAndGenresStoredProcedure(DataSource dataSource) {
								super(dataSource, SPROC_NAME); declareParameter(
								newSqlOutParameter(
								"titles", OracleTypes.CURSOR,
								newTitleMapper())); declareParameter(
								newSqlOutParameter(
								"genres", OracleTypes.CURSOR,
								newGenreMapper())); compile(); }
								publicMap<String, Object> execute() {
								// again, this sproc has no input parameters, so an empty Map is supplied
								return
								super.execute(
								newHashMap<String, Object>()); } }

Notice how the overloaded variants of the declareParameter(..)method that have been used in the TitlesAndGenresStoredProcedureconstructor are passed RowMapperimplementation instances; this is a very convenient and powerful way to reuse existing functionality. The code for the two RowMapperimplementations is provided below.

The TitleMapperclass maps a ResultSetto a Titledomain object for each row in the supplied ResultSet:

								importorg.springframework.jdbc.core.RowMapper;
								importjava.sql.ResultSet;
								importjava.sql.SQLException;
								importcom.foo.domain.Title;
								public
								final
								classTitleMapper
								implementsRowMapper<Title> {
								publicTitle mapRow(ResultSet rs,
								introwNum)
								throwsSQLException { Title title =
								newTitle(); title.setId(rs.getLong(
								"id")); title.setName(rs.getString(
								"name"));
								returntitle; } }

The GenreMapperclass maps a ResultSetto a Genredomain object for each row in the supplied ResultSet.

								importorg.springframework.jdbc.core.RowMapper;
								importjava.sql.ResultSet;
								importjava.sql.SQLException;
								importcom.foo.domain.Genre;
								public
								final
								classGenreMapper
								implementsRowMapper<Genre> {
								publicGenre mapRow(ResultSet rs,
								introwNum)
								throwsSQLException {
								return
								newGenre(rs.getString(
								"name")); } }

To pass parameters to a stored procedure that has one or more input parameters in its definition in the RDBMS, you can code a strongly typed execute(..)method that would delegate to the superclass' untyped execute(Map parameters)method (which has protectedaccess); for example:

								importoracle.jdbc.OracleTypes;
								importorg.springframework.jdbc.core.SqlOutParameter;
								importorg.springframework.jdbc.core.SqlParameter;
								importorg.springframework.jdbc.object.StoredProcedure;
								importjavax.sql.DataSource;
								importjava.sql.Types;
								importjava.util.Date;
								importjava.util.HashMap;
								importjava.util.Map;
								public
								classTitlesAfterDateStoredProcedure
								extendsStoredProcedure {
								private
								static
								finalString SPROC_NAME =
								"TitlesAfterDate";
								private
								static
								finalString CUTOFF_DATE_PARAM =
								"cutoffDate";
								publicTitlesAfterDateStoredProcedure(DataSource dataSource) {
								super(dataSource, SPROC_NAME); declareParameter(
								newSqlParameter(CUTOFF_DATE_PARAM, Types.DATE); declareParameter(
								newSqlOutParameter(
								"titles", OracleTypes.CURSOR,
								newTitleMapper())); compile(); }
								publicMap<String, Object> execute(Date cutoffDate) { Map<String, Object> inputs =
								newHashMap<String, Object>(); inputs.put(CUTOFF_DATE_PARAM, cutoffDate);
								return
								super.execute(inputs); } }

19.7 Common problems with parameter and data value handling

Common problems with parameters and data values exist in the different approaches provided by the Spring Framework JDBC.

19.7.1 Providing SQL type information for parameters

Usually Spring determines the SQL type of the parameters based on the type of parameter passed in. It is possible to explicitly provide the SQL type to be used when setting parameter values. This is sometimes necessary to correctly set NULL values.

You can provide SQL type information in several ways:

  • Many update and query methods of the JdbcTemplatetake an additional parameter in the form of an intarray. This array is used to indicate the SQL type of the corresponding parameter using constant values from the java.sql.Typesclass. Provide one entry for each parameter.
  • You can use the SqlParameterValueclass to wrap the parameter value that needs this additional information.Create a new instance for each value and pass in the SQL type and parameter value in the constructor. You can also provide an optional scale parameter for numeric values.
  • For methods working with named parameters, use the SqlParameterSourceclasses BeanPropertySqlParameterSourceor MapSqlParameterSource. They both have methods for registering the SQL type for any of the named parameter values.

19.7.2 Handling BLOB and CLOB objects

You can store images, other binary data, and large chunks of text in the database. These large objects are called BLOBs (Binary Large OBject) for binary data and CLOBs (Character Large OBject) for character data. In Spring you can handle these large objects by using the JdbcTemplatedirectly and also when using the higher abstractions provided by RDBMS Objects and the SimpleJdbcclasses. All of these approaches use an implementation of the LobHandlerinterface for the actual management of the LOB (Large OBject) data. The LobHandlerprovides access to a LobCreatorclass, through the getLobCreatormethod, used for creating new LOB objects to be inserted.

The LobCreator/LobHandlerprovides the following support for LOB input and output:

  • BLOB

    • byte[] —  getBlobAsBytesand setBlobAsBytes
    • InputStream —  getBlobAsBinaryStreamand setBlobAsBinaryStream

  • CLOB

    • String —  getClobAsStringand setClobAsString
    • InputStream —  getClobAsAsciiStreamand setClobAsAsciiStream
    • Reader —  getClobAsCharacterStreamand setClobAsCharacterStream

The next example shows how to create and insert a BLOB. Later you will see how to read it back from the database.

This example uses a JdbcTemplateand an implementation of the AbstractLobCreatingPreparedStatementCallback. It implements one method, setValues. This method provides a LobCreatorthat you use to set the values for the LOB columns in your SQL insert statement.

For this example we assume that there is a variable, lobHandler, that already is set to an instance of a DefaultLobHandler. You typically set this value through dependency injection.

								finalFile blobIn =
								newFile(
								"spring2004.jpg");
								finalInputStream blobIs =
								newFileInputStream(blobIn);
								finalFile clobIn =
								newFile(
								"large.txt");
								finalInputStream clobIs =
								newFileInputStream(clobIn);
								finalInputStreamReader clobReader =
								newInputStreamReader(clobIs); jdbcTemplate.execute(
								"INSERT INTO lob_table (id, a_clob, a_blob) VALUES (?, ?, ?)",
								newAbstractLobCreatingPreparedStatementCallback(lobHandler) {
								
								
									1
								protected
								voidsetValues(PreparedStatement ps, LobCreator lobCreator)
								throwsSQLException { ps.setLong(
								1,
								1L); lobCreator.setClobAsCharacterStream(ps,
								2, clobReader, (
								int)clobIn.length());
								
								
									2lobCreator.setBlobAsBinaryStream(ps,
								3, blobIs, (
								int)blobIn.length());
								
								
									3} } ); blobIs.close(); clobReader.close();

1

Pass in the lobHandlerthat in this example is a plain DefaultLobHandler.

2

Using the method setClobAsCharacterStream, pass in the contents of the CLOB.

3

Using the method setBlobAsBinaryStream, pass in the contents of the BLOB.
[Note] Note

If you invoke the setBlobAsBinaryStream, setClobAsAsciiStream, or setClobAsCharacterStreammethod on the LobCreatorreturned from DefaultLobHandler.getLobCreator(), you can optionally specify a negative value for the contentLengthargument. If the specified content length is negative, the DefaultLobHandlerwill use the JDBC 4.0 variants of the set-stream methods without a length parameter; otherwise, it will pass the specified length on to the driver.

Consult the documentation for the JDBC driver in use to verify support for streaming a LOB without providing the content length.

Now it’s time to read the LOB data from the database. Again, you use a JdbcTemplatewith the same instance variable lobHandlerand a reference to a DefaultLobHandler.

List<Map<String, Object>> l = jdbcTemplate.query(
								"select id, a_clob, a_blob from lob_table",
								newRowMapper<Map<String, Object>>() {
								publicMap<String, Object> mapRow(ResultSet rs,
								inti)
								throwsSQLException { Map<String, Object> results =
								newHashMap<String, Object>(); String clobText = lobHandler.getClobAsString(rs,
								"a_clob");
								
								
									1results.put(
								"CLOB", clobText);
								byte[] blobBytes = lobHandler.getBlobAsBytes(rs,
								"a_blob");
								
								
									2results.put(
								"BLOB", blobBytes);
								returnresults; } });

1

Using the method getClobAsString, retrieve the contents of the CLOB.

2

Using the method getBlobAsBytes, retrieve the contents of the BLOB.

19.7.3 Passing in lists of values for IN clause

The SQL standard allows for selecting rows based on an expression that includes a variable list of values. A typical example would be select * from T_ACTOR where id in (1, 2, 3). This variable list is not directly supported for prepared statements by the JDBC standard; you cannot declare a variable number of placeholders. You need a number of variations with the desired number of placeholders prepared, or you need to generate the SQL string dynamically once you know how many placeholders are required. The named parameter support provided in the NamedParameterJdbcTemplateand JdbcTemplatetakes the latter approach. Pass in the values as a java.util.Listof primitive objects. This list will be used to insert the required placeholders and pass in the values during the statement execution.

[Note] Note

Be careful when passing in many values. The JDBC standard does not guarantee that you can use more than 100 values for an inexpression list. Various databases exceed this number, but they usually have a hard limit for how many values are allowed. Oracle’s limit is 1000.

In addition to the primitive values in the value list, you can create a java.util.Listof object arrays. This list would support multiple expressions defined for the inclause such as select * from T_ACTOR where (id, last_name) in ((1, 'Johnson'), (2, 'Harrop'\)). This of course requires that your database supports this syntax.

19.7.4 Handling complex types for stored procedure calls

When you call stored procedures you can sometimes use complex types specific to the database. To accommodate these types, Spring provides a SqlReturnTypefor handling them when they are returned from the stored procedure call and SqlTypeValuewhen they are passed in as a parameter to the stored procedure.

Here is an example of returning the value of an Oracle STRUCTobject of the user declared type ITEM_TYPE. The SqlReturnTypeinterface has a single method named getTypeValuethat must be implemented. This interface is used as part of the declaration of an SqlOutParameter.

								finalTestItem =
								newTestItem(
								123L,
								"A test item",
								newSimpleDateFormat(
								"yyyy-M-d").parse(
								"2010-12-31")); declareParameter(
								newSqlOutParameter(
								"item", OracleTypes.STRUCT,
								"ITEM_TYPE",
								newSqlReturnType() {
								publicObject getTypeValue(CallableStatement cs,
								intcolIndx,
								intsqlType, String typeName)
								throwsSQLException { STRUCT struct = (STRUCT) cs.getObject(colIndx); Object[] attr = struct.getAttributes(); TestItem item =
								newTestItem(); item.setId(((Number) attr[
								0]).longValue()); item.setDescription((String) attr[
								1]); item.setExpirationDate((java.util.Date) attr[
								2]);
								returnitem; } }));

You use the SqlTypeValueto pass in the value of a Java object like TestIteminto a stored procedure. The SqlTypeValueinterface has a single method named createTypeValuethat you must implement. The active connection is passed in, and you can use it to create database-specific objects such as StructDescriptors, as shown in the following example, or ArrayDescriptors.

								finalTestItem =
								newTestItem(
								123L,
								"A test item",
								newSimpleDateFormat(
								"yyyy-M-d").parse(
								"2010-12-31")); SqlTypeValue value =
								newAbstractSqlTypeValue() {
								protectedObject createTypeValue(Connection conn,
								intsqlType, String typeName)
								throwsSQLException { StructDescriptor itemDescriptor =
								newStructDescriptor(typeName, conn); Struct item =
								newSTRUCT(itemDescriptor, conn,
								newObject[] { testItem.getId(), testItem.getDescription(),
								newjava.sql.Date(testItem.getExpirationDate().getTime()) });
								returnitem; } };

This SqlTypeValuecan now be added to the Map containing the input parameters for the execute call of the stored procedure.

Another use for the SqlTypeValueis passing in an array of values to an Oracle stored procedure. Oracle has its own internal ARRAYclass that must be used in this case, and you can use the SqlTypeValueto create an instance of the Oracle ARRAYand populate it with values from the Java ARRAY.

								finalLong[] ids =
								newLong[] {
								1L,
								2L}; SqlTypeValue value =
								newAbstractSqlTypeValue() {
								protectedObject createTypeValue(Connection conn,
								intsqlType, String typeName)
								throwsSQLException { ArrayDescriptor arrayDescriptor =
								newArrayDescriptor(typeName, conn); ARRAY idArray =
								newARRAY(arrayDescriptor, conn, ids);
								returnidArray; } };

19.8 Embedded database support

The org.springframework.jdbc.datasource.embeddedpackage provides support for embedded Java database engines. Support for HSQL, H2, and Derbyis provided natively. You can also use an extensible API to plug in new embedded database types and DataSourceimplementations.

19.8.1 Why use an embedded database?

An embedded database is useful during the development phase of a project because of its lightweight nature. Benefits include ease of configuration, quick startup time, testability, and the ability to rapidly evolve SQL during development.

19.8.2 Creating an embedded database using Spring XML

If you want to expose an embedded database instance as a bean in a Spring ApplicationContext, use the embedded-databasetag in the spring-jdbcnamespace:

								<jdbc:embedded-database
								id=
								"dataSource"
								generate-name=
								"true"
								>
								<jdbc:script
								location=
								"classpath:schema.sql"
								/>
								<jdbc:script
								location=
								"classpath:test-data.sql"
								/>
								</jdbc:embedded-database>

The preceding configuration creates an embedded HSQL database populated with SQL from schema.sqland test-data.sqlresources in the root of the classpath. In addition, as a best practice, the embedded database will be assigned a uniquely generated name. The embedded database is made available to the Spring container as a bean of type javax.sql.DataSourcewhich can then be injected into data access objects as needed.

19.8.3 Creating an embedded database programmatically

The EmbeddedDatabaseBuilderclass provides a fluent API for constructing an embedded database programmatically. Use this when you need to create an embedded database in a standalone environment or in a standalone integration test like in the following example.

EmbeddedDatabase db =
								newEmbeddedDatabaseBuilder() .generateUniqueName(true) .setType(H2) .setScriptEncoding(
								"UTF-8") .ignoreFailedDrops(true) .addScript(
								"schema.sql") .addScripts(
								"user_data.sql",
								"country_data.sql") .build();
								// perform actions against the db (EmbeddedDatabase extends javax.sql.DataSource)db.shutdown()

Consult the Javadoc for EmbeddedDatabaseBuilderfor further details on all supported options.

The EmbeddedDatabaseBuildercan also be used to create an embedded database using Java Config like in the following example.

								
									@Configuration
								public
								classDataSourceConfig {
								
									@Bean
								publicDataSource dataSource() {
								return
								newEmbeddedDatabaseBuilder() .generateUniqueName(true) .setType(H2) .setScriptEncoding(
								"UTF-8") .ignoreFailedDrops(true) .addScript(
								"schema.sql") .addScripts(
								"user_data.sql",
								"country_data.sql") .build(); } }

19.8.4 Selecting the embedded database type

Using HSQL

Spring supports HSQL 1.8.0 and above. HSQL is the default embedded database if no type is specified explicitly. To specify HSQL explicitly, set the typeattribute of the embedded-databasetag to HSQL. If you are using the builder API, call the setType(EmbeddedDatabaseType)method with EmbeddedDatabaseType.HSQL.

Using H2

Spring supports the H2 database as well. To enable H2, set the typeattribute of the embedded-databasetag to H2. If you are using the builder API, call the setType(EmbeddedDatabaseType)method with EmbeddedDatabaseType.H2.

Using Derby

Spring also supports Apache Derby 10.5 and above. To enable Derby, set the typeattribute of the embedded-databasetag to DERBY. If you are using the builder API, call the setType(EmbeddedDatabaseType)method with EmbeddedDatabaseType.DERBY.

19.8.5 Testing data access logic with an embedded database

Embedded databases provide a lightweight way to test data access code. The following is a data access integration test template that uses an embedded database. Using a template like this can be useful for one-offswhen the embedded database does not need to be reused across test classes. However, if you wish to create an embedded database that is shared within a test suite, consider using the Spring TestContext Frameworkand configuring the embedded database as a bean in the Spring ApplicationContextas described in Section 19.8.2, “Creating an embedded database using Spring XML”and Section 19.8.3, “Creating an embedded database programmatically”.

								public
								classDataAccessIntegrationTestTemplate {
								privateEmbeddedDatabase db;
								
									@Before
								public
								voidsetUp() {
								// creates an HSQL in-memory database populated from default scripts
								// classpath:schema.sql and classpath:data.sqldb =
								newEmbeddedDatabaseBuilder() .generateUniqueName(true) .addDefaultScripts() .build(); }
								
									@Test
								public
								voidtestDataAccess() { JdbcTemplate template =
								newJdbcTemplate(db); template.query(
								/* ... */); }
								
									@After
								public
								voidtearDown() { db.shutdown(); } }

19.8.6 Generating unique names for embedded databases

Development teams often encounter errors with embedded databases if their test suite inadvertently attempts to recreate additional instances of the same database. This can happen quite easily if an XML configuration file or @Configurationclass is responsible for creating an embedded database and the corresponding configuration is then reused across multiple testing scenarios within the same test suite (i.e., within the same JVM process) –- for example, integration tests against embedded databases whose ApplicationContextconfiguration only differs with regard to which bean definition profiles are active.

The root cause of such errors is the fact that Spring’s EmbeddedDatabaseFactory(used internally by both the <jdbc:embedded-database>XML namespace element and the EmbeddedDatabaseBuilderfor Java Config) will set the name of the embedded database to "testdb"if not otherwise specified. For the case of <jdbc:embedded-database>, the embedded database is typically assigned a name equal to the bean’s id(i.e., often something like "dataSource"). Thus, subsequent attempts to create an embedded database will not result in a new database. Instead, the same JDBC connection URL will be reused, and attempts to create a new embedded database will actually point to an existing embedded database created from the same configuration.

To address this common issue Spring Framework 4.2 provides support for generating uniquenames for embedded databases. To enable the use of generated names, use one of the following options.

  • EmbeddedDatabaseFactory.setGenerateUniqueDatabaseName()
  • EmbeddedDatabaseBuilder.generateUniqueName()
  • <jdbc:embedded-database generate-name="true" …​ >

19.8.7 Extending the embedded database support

Spring JDBC embedded database support can be extended in two ways:

  • Implement EmbeddedDatabaseConfigurerto support a new embedded database type.
  • Implement DataSourceFactoryto support a new DataSourceimplementation, such as a connection pool to manage embedded database connections.

You are encouraged to contribute back extensions to the Spring community at jira.spring.io.

19.9 Initializing a DataSource

The org.springframework.jdbc.datasource.initpackage provides support for initializing an existing DataSource. The embedded database support provides one option for creating and initializing a DataSourcefor an application, but sometimes you need to initialize an instance running on a server somewhere.

19.9.1 Initializing a database using Spring XML

If you want to initialize a database and you can provide a reference to a DataSourcebean, use the initialize-databasetag in the spring-jdbcnamespace:

								<jdbc:initialize-database
								data-source=
								"dataSource"
								>
								<jdbc:script
								location=
								"classpath:com/foo/sql/db-schema.sql"
								/>
								<jdbc:script
								location=
								"classpath:com/foo/sql/db-test-data.sql"
								/>
								</jdbc:initialize-database>

The example above executes the two scripts specified against the database: the first script creates a schema, and the second populates tables with a test data set. The script locations can also be patterns with wildcards in the usual ant style used for resources in Spring (e.g. classpath*:/com/foo/**/sql/*-data.sql). If a pattern is used, the scripts are executed in lexical order of their URL or filename.

The default behavior of the database initializer is to unconditionally execute the scripts provided. This will not always be what you want, for instance, if you are executing the scripts against a database that already has test data in it. The likelihood of accidentally deleting data is reduced by following the common pattern (as shown above) of creating the tables first and then inserting the data — the first step will fail if the tables already exist.

However, to gain more control over the creation and deletion of existing data, the XML namespace provides a few additional options. The first is a flag to switch the initialization on and off. This can be set according to the environment (e.g. to pull a boolean value from system properties or an environment bean), for example:

								<jdbc:initialize-database
								data-source=
								"dataSource"
								
									enabled="#{systemProperties.INITIALIZE_DATABASE}">
								<jdbc:script
								location=
								"..."
								/>
								</jdbc:initialize-database>

The second option to control what happens with existing data is to be more tolerant of failures. To this end you can control the ability of the initializer to ignore certain errors in the SQL it executes from the scripts, for example:

								<jdbc:initialize-database
								data-source=
								"dataSource"
								
									ignore-failures="DROPS">
								<jdbc:script
								location=
								"..."
								/>
								</jdbc:initialize-database>

In this example we are saying we expect that sometimes the scripts will be executed against an empty database, and there are some DROPstatements in the scripts which would therefore fail. So failed SQL DROPstatements will be ignored, but other failures will cause an exception. This is useful if your SQL dialect doesn’t support DROP …​ IF EXISTS(or similar) but you want to unconditionally remove all test data before re-creating it. In that case the first script is usually a set of DROPstatements, followed by a set of CREATEstatements.

The ignore-failuresoption can be set to NONE(the default), DROPS(ignore failed drops), or ALL(ignore all failures).

Each statement should be separated by ;or a new line if the ;character is not present at all in the script. You can control that globally or script by script, for example:

								<jdbc:initialize-database
								data-source=
								"dataSource"
								
									separator="@@">
								<jdbc:script
								location=
								"classpath:com/foo/sql/db-schema.sql"
								
									separator=";"/>
								<jdbc:script
								location=
								"classpath:com/foo/sql/db-test-data-1.sql"
								/>
								<jdbc:script
								location=
								"classpath:com/foo/sql/db-test-data-2.sql"
								/>
								</jdbc:initialize-database>

In this example, the two test-datascripts use @@as statement separator and only the db-schema.sqluses ;. This configuration specifies that the default separator is @@and override that default for the db-schemascript.

If you need more control than you get from the XML namespace, you can simply use the DataSourceInitializerdirectly and define it as a component in your application.

Initialization of other components that depend on the database

A large class of applications can just use the database initializer with no further complications: those that do not use the database until after the Spring context has started. If your application is notone of those then you might need to read the rest of this section.

The database initializer depends on a DataSourceinstance and executes the scripts provided in its initialization callback (analogous to an init-methodin an XML bean definition, a @PostConstructmethod in a component, or the afterPropertiesSet()method in a component that implements InitializingBean). If other beans depend on the same data source and also use the data source in an initialization callback, then there might be a problem because the data has not yet been initialized. A common example of this is a cache that initializes eagerly and loads data from the database on application startup.

To get around this issue you have two options: change your cache initialization strategy to a later phase, or ensure that the database initializer is initialized first.

The first option might be easy if the application is in your control, and not otherwise. Some suggestions for how to implement this include:

  • Make the cache initialize lazily on first usage, which improves application startup time.
  • Have your cache or a separate component that initializes the cache implement Lifecycleor SmartLifecycle. When the application context starts up a SmartLifecyclecan be automatically started if its autoStartupflag is set, and a Lifecyclecan be started manually by calling ConfigurableApplicationContext.start()on the enclosing context.
  • Use a Spring ApplicationEventor similar custom observer mechanism to trigger the cache initialization. ContextRefreshedEventis always published by the context when it is ready for use (after all beans have been initialized), so that is often a useful hook (this is how the SmartLifecycleworks by default).

The second option can also be easy. Some suggestions on how to implement this include:

  • Rely on the default behavior of the Spring BeanFactory, which is that beans are initialized in registration order. You can easily arrange that by adopting the common practice of a set of <import/>elements in XML configuration that order your application modules, and ensure that the database and database initialization are listed first.
  • Separate the DataSourceand the business components that use it, and control their startup order by putting them in separate ApplicationContextinstances (e.g. the parent context contains the DataSource, and child context contains the business components). This structure is common in Spring web applications but can be more generally applied.

20. Object Relational Mapping (ORM) Data Access

20.1 Introduction to ORM with Spring

The Spring Framework supports integration with Hibernate, Java Persistence API (JPA) and Java Data Objects (JDO) for resource management, data access object (DAO) implementations, and transaction strategies. For example, for Hibernate there is first-class support with several convenient IoC features that address many typical Hibernate integration issues. You can configure all of the supported features for O/R (object relational) mapping tools through Dependency Injection. They can participate in Spring’s resource and transaction management, and they comply with Spring’s generic transaction and DAO exception hierarchies. The recommended integration style is to code DAOs against plain Hibernate, JPA, and JDO APIs. The older style of using Spring’s DAO templates is no longer recommended; however, coverage of this style can be found in the Section 39.1, “Classic ORM usage”in the appendices.

Spring adds significant enhancements to the ORM layer of your choice when you create data access applications. You can leverage as much of the integration support as you wish, and you should compare this integration effort with the cost and risk of building a similar infrastructure in-house. You can use much of the ORM support as you would a library, regardless of technology, because everything is designed as a set of reusable JavaBeans. ORM in a Spring IoC container facilitates configuration and deployment. Thus most examples in this section show configuration inside a Spring container.

Benefits of using the Spring Framework to create your ORM DAOs include:

  • Easier testing.Spring’s IoC approach makes it easy to swap the implementations and configuration locations of Hibernate SessionFactoryinstances, JDBC DataSourceinstances, transaction managers, and mapped object implementations (if needed). This in turn makes it much easier to test each piece of persistence-related code in isolation.
  • Common data access exceptions.Spring can wrap exceptions from your ORM tool, converting them from proprietary (potentially checked) exceptions to a common runtime DataAccessException hierarchy. This feature allows you to handle most persistence exceptions, which are non-recoverable, only in the appropriate layers, without annoying boilerplate catches, throws, and exception declarations. You can still trap and handle exceptions as necessary. Remember that JDBC exceptions (including DB-specific dialects) are also converted to the same hierarchy, meaning that you can perform some operations with JDBC within a consistent programming model.
  • General resource management.Spring application contexts can handle the location and configuration of Hibernate SessionFactoryinstances, JPA EntityManagerFactoryinstances, JDBC DataSourceinstances, and other related resources. This makes these values easy to manage and change. Spring offers efficient, easy, and safe handling of persistence resources. For example, related code that uses Hibernate generally needs to use the same Hibernate Sessionto ensure efficiency and proper transaction handling. Spring makes it easy to create and bind a Sessionto the current thread transparently, by exposing a current Sessionthrough the Hibernate SessionFactory. Thus Spring solves many chronic problems of typical Hibernate usage, for any local or JTA transaction environment.
  • Integrated transaction management.You can wrap your ORM code with a declarative, aspect-oriented programming (AOP) style method interceptor either through the @Transactionalannotation or by explicitly configuring the transaction AOP advice in an XML configuration file. In both cases, transaction semantics and exception handling (rollback, and so on) are handled for you. As discussed below, in Resource and transaction management, you can also swap various transaction managers, without affecting your ORM-related code. For example, you can swap between local transactions and JTA, with the same full services (such as declarative transactions) available in both scenarios. Additionally, JDBC-related code can fully integrate transactionally with the code you use to do ORM. This is useful for data access that is not suitable for ORM, such as batch processing and BLOB streaming, which still need to share common transactions with ORM operations.
[Tip] Tip

For more comprehensive ORM support, including support for alternative database technologies such as MongoDB, you might want to check out the Spring Datasuite of projects. If you are a JPA user, the Getting Started Accessing Data with JPAguide from https://spring.ioprovides a great introduction.

20.2 General ORM integration considerations

This section highlights considerations that apply to all ORM technologies. The Section 20.3, “Hibernate”section provides more details and also show these features and configurations in a concrete context.

The major goal of Spring’s ORM integration is clear application layering, with any data access and transaction technology, and for loose coupling of application objects. No more business service dependencies on the data access or transaction strategy, no more hard-coded resource lookups, no more hard-to-replace singletons, no more custom service registries. One simple and consistent approach to wiring up application objects, keeping them as reusable and free from container dependencies as possible. All the individual data access features are usable on their own but integrate nicely with Spring’s application context concept, providing XML-based configuration and cross-referencing of plain JavaBean instances that need not be Spring-aware. In a typical Spring application, many important objects are JavaBeans: data access templates, data access objects, transaction managers, business services that use the data access objects and transaction managers, web view resolvers, web controllers that use the business services,and so on.

20.2.1 Resource and transaction management

Typical business applications are cluttered with repetitive resource management code. Many projects try to invent their own solutions, sometimes sacrificing proper handling of failures for programming convenience. Spring advocates simple solutions for proper resource handling, namely IoC through templating in the case of JDBC and applying AOP interceptors for the ORM technologies.

The infrastructure provides proper resource handling and appropriate conversion of specific API exceptions to an unchecked infrastructure exception hierarchy. Spring introduces a DAO exception hierarchy, applicable to any data access strategy. For direct JDBC, the JdbcTemplateclass mentioned in a previous section provides connection handling and proper conversion of SQLExceptionto the DataAccessExceptionhierarchy, including translation of database-specific SQL error codes to meaningful exception classes. For ORM technologies, see the next section for how to get the same exception translation benefits.

When it comes to transaction management, the JdbcTemplateclass hooks in to the Spring transaction support and supports both JTA and JDBC transactions, through respective Spring transaction managers. For the supported ORM technologies Spring offers Hibernate, JPA and JDO support through the Hibernate, JPA, and JDO transaction managers as well as JTA support. For details on transaction support, see the Chapter 17, Transaction Management chapter.

20.2.2 Exception translation

When you use Hibernate, JPA, or JDO in a DAO, you must decide how to handle the persistence technology’s native exception classes. The DAO throws a subclass of a HibernateException, PersistenceExceptionor JDOExceptiondepending on the technology. These exceptions are all run-time exceptions and do not have to be declared or caught. You may also have to deal with IllegalArgumentExceptionand IllegalStateException. This means that callers can only treat exceptions as generally fatal, unless they want to depend on the persistence technology’s own exception structure. Catching specific causes such as an optimistic locking failure is not possible without tying the caller to the implementation strategy. This trade off might be acceptable to applications that are strongly ORM-based and/or do not need any special exception treatment. However, Spring enables exception translation to be applied transparently through the @Repositoryannotation:

								
									@Repository
								public
								classProductDaoImpl
								implementsProductDao {
								// class body here...}
								<beans>
								<!-- Exception translation bean post processor -->
								<bean
								class=
								"org.springframework.dao.annotation.PersistenceExceptionTranslationPostProcessor"
								/>
								<bean
								id=
								"myProductDao"
								class=
								"product.ProductDaoImpl"
								/>
								</beans>

The postprocessor automatically looks for all exception translators (implementations of the PersistenceExceptionTranslatorinterface) and advises all beans marked with the @Repositoryannotation so that the discovered translators can intercept and apply the appropriate translation on the thrown exceptions.

In summary: you can implement DAOs based on the plain persistence technology’s API and annotations, while still benefiting from Spring-managed transactions, dependency injection, and transparent exception conversion (if desired) to Spring’s custom exception hierarchies.

20.3 Hibernate

We will start with a coverage of Hibernate 5in a Spring environment, using it to demonstrate the approach that Spring takes towards integrating O/R mappers. This section will cover many issues in detail and show different variations of DAO implementations and transaction demarcation. Most of these patterns can be directly translated to all other supported ORM tools. The following sections in this chapter will then cover the other ORM technologies, showing briefer examples there.

[Note] Note

As of Spring 4.0, Spring requires Hibernate 3.6 or later. Note that the Hibernate team stopped supporting Hibernate 3 years ago and even phased out support for Hibernate 4.x in late 2015. We therefore recommend Hibernate 5.1 and higher from a 2016+ perspective.

20.3.1 SessionFactory setup in a Spring container

To avoid tying application objects to hard-coded resource lookups, you can define resources such as a JDBC DataSourceor a Hibernate SessionFactoryas beans in the Spring container. Application objects that need to access resources receive references to such predefined instances through bean references, as illustrated in the DAO definition in the next section.

The following excerpt from an XML application context definition shows how to set up a JDBC DataSourceand a Hibernate SessionFactoryon top of it:

								<beans>
								<bean
								id=
								"myDataSource"
								class=
								"org.apache.commons.dbcp.BasicDataSource"
								destroy-method=
								"close"
								>
								<property
								name=
								"driverClassName"
								value=
								"org.hsqldb.jdbcDriver"
								/>
								<property
								name=
								"url"
								value=
								"jdbc:hsqldb:hsql://localhost:9001"
								/>
								<property
								name=
								"username"
								value=
								"sa"
								/>
								<property
								name=
								"password"
								value=
								""
								/>
								</bean>
								<bean
								id=
								"mySessionFactory"
								class=
								"org.springframework.orm.hibernate5.LocalSessionFactoryBean"
								>
								<property
								name=
								"dataSource"
								ref=
								"myDataSource"
								/>
								<property
								name=
								"mappingResources"
								>
								<list>
								<value>product.hbm.xml
								</value>
								</list>
								</property>
								<property
								name=
								"hibernateProperties"
								>
								<value>hibernate.dialect=org.hibernate.dialect.HSQLDialect
								</value>
								</property>
								</bean>
								</beans>

Switching from a local Jakarta Commons DBCP BasicDataSourceto a JNDI-located DataSource(usually managed by an application server) is just a matter of configuration:

								<beans>
								<jee:jndi-lookup
								id=
								"myDataSource"
								jndi-name=
								"java:comp/env/jdbc/myds"
								/>
								</beans>

You can also access a JNDI-located SessionFactory, using Spring’s JndiObjectFactoryBean/ <jee:jndi-lookup>to retrieve and expose it. However, that is typically not common outside of an EJB context.

20.3.2 Implementing DAOs based on plain Hibernate API

Hibernate has a feature called contextual sessions, wherein Hibernate itself manages one current Sessionper transaction. This is roughly equivalent to Spring’s synchronization of one Hibernate Sessionper transaction. A corresponding DAO implementation resembles the following example, based on the plain Hibernate API:

								public
								classProductDaoImpl
								implementsProductDao {
								privateSessionFactory sessionFactory;
								public
								voidsetSessionFactory(SessionFactory sessionFactory) {
								this.sessionFactory = sessionFactory; }
								publicCollection loadProductsByCategory(String category) {
								return
								this.sessionFactory.getCurrentSession() .createQuery(
								"from test.Product product where product.category=?") .setParameter(
								0, category) .list(); } }

This style is similar to that of the Hibernate reference documentation and examples, except for holding the SessionFactoryin an instance variable. We strongly recommend such an instance-based setup over the old-school static HibernateUtilclass from Hibernate’s CaveatEmptor sample application. (In general, do not keep any resources in staticvariables unless absolutelynecessary.)

The above DAO follows the dependency injection pattern: it fits nicely into a Spring IoC container, just as it would if coded against Spring’s HibernateTemplate. Of course, such a DAO can also be set up in plain Java (for example, in unit tests). Simply instantiate it and call setSessionFactory(..)with the desired factory reference. As a Spring bean definition, the DAO would resemble the following:

								<beans>
								<bean
								id=
								"myProductDao"
								class=
								"product.ProductDaoImpl"
								>
								<property
								name=
								"sessionFactory"
								ref=
								"mySessionFactory"
								/>
								</bean>
								</beans>

The main advantage of this DAO style is that it depends on Hibernate API only; no import of any Spring class is required. This is of course appealing from a non-invasiveness perspective, and will no doubt feel more natural to Hibernate developers.

However, the DAO throws plain HibernateException(which is unchecked, so does not have to be declared or caught), which means that callers can only treat exceptions as generally fatal - unless they want to depend on Hibernate’s own exception hierarchy. Catching specific causes such as an optimistic locking failure is not possible without tying the caller to the implementation strategy. This trade off might be acceptable to applications that are strongly Hibernate-based and/or do not need any special exception treatment.

Fortunately, Spring’s LocalSessionFactoryBeansupports Hibernate’s SessionFactory.getCurrentSession()method for any Spring transaction strategy, returning the current Spring-managed transactional Sessioneven with HibernateTransactionManager. Of course, the standard behavior of that method remains the return of the current Sessionassociated with the ongoing JTA transaction, if any. This behavior applies regardless of whether you are using Spring’s JtaTransactionManager, EJB container managed transactions (CMTs), or JTA.

In summary: you can implement DAOs based on the plain Hibernate API, while still being able to participate in Spring-managed transactions.

20.3.3 Declarative transaction demarcation

We recommend that you use Spring’s declarative transaction support, which enables you to replace explicit transaction demarcation API calls in your Java code with an AOP transaction interceptor. This transaction interceptor can be configured in a Spring container using either Java annotations or XML.This declarative transaction capability allows you to keep business services free of repetitive transaction demarcation code and to focus on adding business logic, which is the real value of your application.

[Note] Note

Prior to continuing, you are stronglyencouraged to read Section 17.5, “Declarative transaction management”if you have not done so.

Furthermore, transaction semantics like propagation behavior and isolation level can be changed in a configuration file and do not affect the business service implementations.

The following example shows how you can configure an AOP transaction interceptor, using XML, for a simple service class:

								<?xml version="1.0" encoding="UTF-8"?>
								<beans
								xmlns=
								"http://www.springframework.org/schema/beans"
								xmlns:xsi=
								"http://www.w3.org/2001/XMLSchema-instance"
								xmlns:aop=
								"http://www.springframework.org/schema/aop"
								xmlns:tx=
								"http://www.springframework.org/schema/tx"
								xsi:schemaLocation=
								" http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd"
								>
								<!-- SessionFactory, DataSource, etc. omitted -->
								<bean
								id=
								"transactionManager"
								class=
								"org.springframework.orm.hibernate5.HibernateTransactionManager"
								>
								<property
								name=
								"sessionFactory"
								ref=
								"sessionFactory"
								/>
								</bean>
								<aop:config>
								<aop:pointcut
								id=
								"productServiceMethods"
								expression=
								"execution(* product.ProductService.*(..))"
								/>
								<aop:advisor
								advice-ref=
								"txAdvice"
								pointcut-ref=
								"productServiceMethods"
								/>
								</aop:config>
								<tx:advice
								id=
								"txAdvice"
								transaction-manager=
								"myTxManager"
								>
								<tx:attributes>
								<tx:method
								name=
								"increasePrice*"
								propagation=
								"REQUIRED"
								/>
								<tx:method
								name=
								"someOtherBusinessMethod"
								propagation=
								"REQUIRES_NEW"
								/>
								<tx:method
								name=
								"*"
								propagation=
								"SUPPORTS"
								read-only=
								"true"
								/>
								</tx:attributes>
								</tx:advice>
								<bean
								id=
								"myProductService"
								class=
								"product.SimpleProductService"
								>
								<property
								name=
								"productDao"
								ref=
								"myProductDao"
								/>
								</bean>
								</beans>

This is the service class that is advised:

								public
								classProductServiceImpl
								implementsProductService {
								privateProductDao productDao;
								public
								voidsetProductDao(ProductDao productDao) {
								this.productDao = productDao; }
								// notice the absence of transaction demarcation code in this method
								// Spring's declarative transaction infrastructure will be demarcating
								// transactions on your behalf
								public
								voidincreasePriceOfAllProductsInCategory(
								finalString category) { List productsToChange =
								this.productDao.loadProductsByCategory(category);
								// ...} }

We also show an attribute-support based configuration, in the following example. You annotate the service layer with @Transactional annotations and instruct the Spring container to find these annotations and provide transactional semantics for these annotated methods.

								public
								classProductServiceImpl
								implementsProductService {
								privateProductDao productDao;
								public
								voidsetProductDao(ProductDao productDao) {
								this.productDao = productDao; }
								
									@Transactional
								public
								voidincreasePriceOfAllProductsInCategory(
								finalString category) { List productsToChange =
								this.productDao.loadProductsByCategory(category);
								// ...}
								
									@Transactional(readOnly = true)
								publicList<Product> findAllProducts() {
								return
								this.productDao.findAllProducts(); } }

As you can see from the following configuration example, the configuration is much simplified, compared to the XML example above, while still providing the same functionality driven by the annotations in the service layer code. All you need to provide is the TransactionManager implementation and a "<tx:annotation-driven/>" entry.

								<?xml version="1.0" encoding="UTF-8"?>
								<beans
								xmlns=
								"http://www.springframework.org/schema/beans"
								xmlns:xsi=
								"http://www.w3.org/2001/XMLSchema-instance"
								xmlns:aop=
								"http://www.springframework.org/schema/aop"
								xmlns:tx=
								"http://www.springframework.org/schema/tx"
								xsi:schemaLocation=
								" http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd"
								>
								<!-- SessionFactory, DataSource, etc. omitted -->
								<bean
								id=
								"transactionManager"
								class=
								"org.springframework.orm.hibernate5.HibernateTransactionManager"
								>
								<property
								name=
								"sessionFactory"
								ref=
								"sessionFactory"
								/>
								</bean>
								<tx:annotation-driven/>
								<bean
								id=
								"myProductService"
								class=
								"product.SimpleProductService"
								>
								<property
								name=
								"productDao"
								ref=
								"myProductDao"
								/>
								</bean>
								</beans>

20.3.4 Programmatic transaction demarcation

You can demarcate transactions in a higher level of the application, on top of such lower-level data access services spanning any number of operations. Nor do restrictions exist on the implementation of the surrounding business service; it just needs a Spring PlatformTransactionManager. Again, the latter can come from anywhere, but preferably as a bean reference through a setTransactionManager(..)method, just as the productDAOshould be set by a setProductDao(..)method. The following snippets show a transaction manager and a business service definition in a Spring application context, and an example for a business method implementation:

								<beans>
								<bean
								id=
								"myTxManager"
								class=
								"org.springframework.orm.hibernate5.HibernateTransactionManager"
								>
								<property
								name=
								"sessionFactory"
								ref=
								"mySessionFactory"
								/>
								</bean>
								<bean
								id=
								"myProductService"
								class=
								"product.ProductServiceImpl"
								>
								<property
								name=
								"transactionManager"
								ref=
								"myTxManager"
								/>
								<property
								name=
								"productDao"
								ref=
								"myProductDao"
								/>
								</bean>
								</beans>
								public
								classProductServiceImpl
								implementsProductService {
								privateTransactionTemplate transactionTemplate;
								privateProductDao productDao;
								public
								voidsetTransactionManager(PlatformTransactionManager transactionManager) {
								this.transactionTemplate =
								newTransactionTemplate(transactionManager); }
								public
								voidsetProductDao(ProductDao productDao) {
								this.productDao = productDao; }
								public
								voidincreasePriceOfAllProductsInCategory(
								finalString category) {
								this.transactionTemplate.execute(
								newTransactionCallbackWithoutResult() {
								public
								voiddoInTransactionWithoutResult(TransactionStatus status) { List productsToChange =
								this.productDao.loadProductsByCategory(category);
								// do the price increase...} }); } }

Spring’s TransactionInterceptorallows any checked application exception to be thrown with the callback code, while TransactionTemplateis restricted to unchecked exceptions within the callback. TransactionTemplatetriggers a rollback in case of an unchecked application exception, or if the transaction is marked rollback-only by the application (via TransactionStatus). TransactionInterceptorbehaves the same way by default but allows configurable rollback policies per method.

20.3.5 Transaction management strategies

Both TransactionTemplateand TransactionInterceptordelegate the actual transaction handling to a PlatformTransactionManagerinstance, which can be a HibernateTransactionManager(for a single Hibernate SessionFactory, using a ThreadLocal Sessionunder the hood) or a JtaTransactionManager(delegating to the JTA subsystem of the container) for Hibernate applications. You can even use a custom PlatformTransactionManagerimplementation. Switching from native Hibernate transaction management to JTA, such as when facing distributed transaction requirements for certain deployments of your application, is just a matter of configuration. Simply replace the Hibernate transaction manager with Spring’s JTA transaction implementation. Both transaction demarcation and data access code will work without changes, because they just use the generic transaction management APIs.

For distributed transactions across multiple Hibernate session factories, simply combine JtaTransactionManageras a transaction strategy with multiple LocalSessionFactoryBeandefinitions. Each DAO then gets one specific SessionFactoryreference passed into its corresponding bean property. If all underlying JDBC data sources are transactional container ones, a business service can demarcate transactions across any number of DAOs and any number of session factories without special regard, as long as it is using JtaTransactionManageras the strategy.

								<beans>
								<jee:jndi-lookup
								id=
								"dataSource1"
								jndi-name=
								"java:comp/env/jdbc/myds1"
								/>
								<jee:jndi-lookup
								id=
								"dataSource2"
								jndi-name=
								"java:comp/env/jdbc/myds2"
								/>
								<bean
								id=
								"mySessionFactory1"
								class=
								"org.springframework.orm.hibernate5.LocalSessionFactoryBean"
								>
								<property
								name=
								"dataSource"
								ref=
								"myDataSource1"
								/>
								<property
								name=
								"mappingResources"
								>
								<list>
								<value>product.hbm.xml
								</value>
								</list>
								</property>
								<property
								name=
								"hibernateProperties"
								>
								<value>hibernate.dialect=org.hibernate.dialect.MySQLDialect hibernate.show_sql=true
								</value>
								</property>
								</bean>
								<bean
								id=
								"mySessionFactory2"
								class=
								"org.springframework.orm.hibernate5.LocalSessionFactoryBean"
								>
								<property
								name=
								"dataSource"
								ref=
								"myDataSource2"
								/>
								<property
								name=
								"mappingResources"
								>
								<list>
								<value>inventory.hbm.xml
								</value>
								</list>
								</property>
								<property
								name=
								"hibernateProperties"
								>
								<value>hibernate.dialect=org.hibernate.dialect.OracleDialect
								</value>
								</property>
								</bean>
								<bean
								id=
								"myTxManager"
								class=
								"org.springframework.transaction.jta.JtaTransactionManager"
								/>
								<bean
								id=
								"myProductDao"
								class=
								"product.ProductDaoImpl"
								>
								<property
								name=
								"sessionFactory"
								ref=
								"mySessionFactory1"
								/>
								</bean>
								<bean
								id=
								"myInventoryDao"
								class=
								"product.InventoryDaoImpl"
								>
								<property
								name=
								"sessionFactory"
								ref=
								"mySessionFactory2"
								/>
								</bean>
								<bean
								id=
								"myProductService"
								class=
								"product.ProductServiceImpl"
								>
								<property
								name=
								"productDao"
								ref=
								"myProductDao"
								/>
								<property
								name=
								"inventoryDao"
								ref=
								"myInventoryDao"
								/>
								</bean>
								<aop:config>
								<aop:pointcut
								id=
								"productServiceMethods"
								expression=
								"execution(* product.ProductService.*(..))"
								/>
								<aop:advisor
								advice-ref=
								"txAdvice"
								pointcut-ref=
								"productServiceMethods"
								/>
								</aop:config>
								<tx:advice
								id=
								"txAdvice"
								transaction-manager=
								"myTxManager"
								>
								<tx:attributes>
								<tx:method
								name=
								"increasePrice*"
								propagation=
								"REQUIRED"
								/>
								<tx:method
								name=
								"someOtherBusinessMethod"
								propagation=
								"REQUIRES_NEW"
								/>
								<tx:method
								name=
								"*"
								propagation=
								"SUPPORTS"
								read-only=
								"true"
								/>
								</tx:attributes>
								</tx:advice>
								</beans>

Both HibernateTransactionManagerand JtaTransactionManagerallow for proper JVM-level cache handling with Hibernate, without container-specific transaction manager lookup or a JCA connector (if you are not using EJB to initiate transactions).

HibernateTransactionManagercan export the Hibernate JDBC Connectionto plain JDBC access code, for a specific DataSource. This capability allows for high-level transaction demarcation with mixed Hibernate and JDBC data access completely without JTA, if you are accessing only one database. HibernateTransactionManagerautomatically exposes the Hibernate transaction as a JDBC transaction if you have set up the passed-in SessionFactorywith a DataSourcethrough the dataSourceproperty of the LocalSessionFactoryBeanclass. Alternatively, you can specify explicitly the DataSourcefor which the transactions are supposed to be exposed through the dataSourceproperty of the HibernateTransactionManagerclass.

20.3.6 Comparing container-managed and locally defined resources

You can switch between a container-managed JNDI SessionFactoryand a locally defined one, without having to change a single line of application code. Whether to keep resource definitions in the container or locally within the application is mainly a matter of the transaction strategy that you use. Compared to a Spring-defined local SessionFactory, a manually registered JNDI SessionFactorydoes not provide any benefits. Deploying a SessionFactorythrough Hibernate’s JCA connector provides the added value of participating in the Java EE server’s management infrastructure, but does not add actual value beyond that.

Spring’s transaction support is not bound to a container. Configured with any strategy other than JTA, transaction support also works in a stand-alone or test environment. Especially in the typical case of single-database transactions, Spring’s single-resource local transaction support is a lightweight and powerful alternative to JTA. When you use local EJB stateless session beans to drive transactions, you depend both on an EJB container and JTA, even if you access only a single database, and only use stateless session beans to provide declarative transactions through container-managed transactions. Also, direct use of JTA programmatically requires a Java EE environment as well. JTA does not involve only container dependencies in terms of JTA itself and of JNDI DataSourceinstances. For non-Spring, JTA-driven Hibernate transactions, you have to use the Hibernate JCA connector, or extra Hibernate transaction code with the TransactionManagerLookupconfigured for proper JVM-level caching.

Spring-driven transactions can work as well with a locally defined Hibernate SessionFactoryas they do with a local JDBC DataSourceif they are accessing a single database. Thus you only have to use Spring’s JTA transaction strategy when you have distributed transaction requirements. A JCA connector requires container-specific deployment steps, and obviously JCA support in the first place. This configuration requires more work than deploying a simple web application with local resource definitions and Spring-driven transactions. Also, you often need the Enterprise Edition of your container if you are using, for example, WebLogic Express, which does not provide JCA. A Spring application with local resources and transactions spanning one single database works in any Java EE web container (without JTA, JCA, or EJB) such as Tomcat, Resin, or even plain Jetty. Additionally, you can easily reuse such a middle tier in desktop applications or test suites.

All things considered, if you do not use EJBs, stick with local SessionFactorysetup and Spring’s HibernateTransactionManageror JtaTransactionManager. You get all of the benefits, including proper transactional JVM-level caching and distributed transactions, without the inconvenience of container deployment. JNDI registration of a Hibernate SessionFactorythrough the JCA connector only adds value when used in conjunction with EJBs.

20.3.7 Spurious application server warnings with Hibernate

In some JTA environments with very strict XADataSourceimplementations — currently only some WebLogic Server and WebSphere versions — when Hibernate is configured without regard to the JTA PlatformTransactionManagerobject for that environment, it is possible for spurious warning or exceptions to show up in the application server log. These warnings or exceptions indicate that the connection being accessed is no longer valid, or JDBC access is no longer valid, possibly because the transaction is no longer active. As an example, here is an actual exception from WebLogic:

java.sql.SQLException: The transaction is no longer active - status: 'Committed'. No further JDBC access is allowed within this transaction.

You resolve this warning by simply making Hibernate aware of the JTA PlatformTransactionManagerinstance, to which it will synchronize (along with Spring). You have two options for doing this:

  • If in your application context you are already directly obtaining the JTA PlatformTransactionManagerobject (presumably from JNDI through JndiObjectFactoryBeanor <jee:jndi-lookup>) and feeding it, for example, to Spring’s JtaTransactionManager, then the easiest way is to specify a reference to the bean defining this JTA PlatformTransactionManagerinstance as the value of the jtaTransactionManagerproperty for LocalSessionFactoryBean.Spring then makes the object available to Hibernate.
  • More likely you do not already have the JTA PlatformTransactionManagerinstance, because Spring’s JtaTransactionManagercan find it itself. Thus you need to configure Hibernate to look up JTA PlatformTransactionManagerdirectly. You do this by configuring an application server- specific TransactionManagerLookupclass in the Hibernate configuration, as described in the Hibernate manual.

The remainder of this section describes the sequence of events that occur with and without Hibernate’s awareness of the JTA PlatformTransactionManager.

When Hibernate is not configured with any awareness of the JTA PlatformTransactionManager, the following events occur when a JTA transaction commits:

  • The JTA transaction commits.
  • Spring’s JtaTransactionManageris synchronized to the JTA transaction, so it is called back through an afterCompletioncallback by the JTA transaction manager.
  • Among other activities, this synchronization can trigger a callback by Spring to Hibernate, through Hibernate’s afterTransactionCompletioncallback (used to clear the Hibernate cache), followed by an explicit close()call on the Hibernate Session, which causes Hibernate to attempt to close()the JDBC Connection.
  • In some environments, this Connection.close()call then triggers the warning or error, as the application server no longer considers the Connectionusable at all, because the transaction has already been committed.

When Hibernate is configured with awareness of the JTA PlatformTransactionManager, the following events occur when a JTA transaction commits:

  • the JTA transaction is ready to commit.
  • Spring’s JtaTransactionManageris synchronized to the JTA transaction, so the transaction is called back through a beforeCompletioncallback by the JTA transaction manager.
  • Spring is aware that Hibernate itself is synchronized to the JTA transaction, and behaves differently than in the previous scenario. Assuming the Hibernate Sessionneeds to be closed at all, Spring will close it now.
  • The JTA transaction commits.
  • Hibernate is synchronized to the JTA transaction, so the transaction is called back through an afterCompletioncallback by the JTA transaction manager, and can properly clear its cache.

20.4 JDO

Spring supports the standard JDO 2.0 and 2.1 APIs as data access strategy, following the same style as the Hibernate support. The corresponding integration classes reside in the org.springframework.orm.jdopackage.

20.4.1 PersistenceManagerFactory setup

Spring provides a LocalPersistenceManagerFactoryBeanclass that allows you to define a local JDO PersistenceManagerFactorywithin a Spring application context:

								<beans>
								<bean
								id=
								"myPmf"
								class=
								"org.springframework.orm.jdo.LocalPersistenceManagerFactoryBean"
								>
								<property
								name=
								"configLocation"
								value=
								"classpath:kodo.properties"
								/>
								</bean>
								</beans>

Alternatively, you can set up a PersistenceManagerFactorythrough direct instantiation of a PersistenceManagerFactoryimplementation class. A JDO PersistenceManagerFactoryimplementation class follows the JavaBeans pattern, just like a JDBC DataSourceimplementation class, which is a natural fit for a configuration that uses Spring. This setup style usually supports a Spring-defined JDBC DataSource, passed into the connectionFactoryproperty. For example, for the open source JDO implementation DataNucleus (formerly JPOX) ( http://www.datanucleus.org/), this is the XML configuration of the PersistenceManagerFactoryimplementation:

								<beans>
								<bean
								id=
								"dataSource"
								class=
								"org.apache.commons.dbcp.BasicDataSource"
								destroy-method=
								"close"
								>
								<property
								name=
								"driverClassName"
								value=
								"${jdbc.driverClassName}"
								/>
								<property
								name=
								"url"
								value=
								"${jdbc.url}"
								/>
								<property
								name=
								"username"
								value=
								"${jdbc.username}"
								/>
								<property
								name=
								"password"
								value=
								"${jdbc.password}"
								/>
								</bean>
								<bean
								id=
								"myPmf"
								class=
								"org.datanucleus.jdo.JDOPersistenceManagerFactory"
								destroy-method=
								"close"
								>
								<property
								name=
								"connectionFactory"
								ref=
								"dataSource"
								/>
								<property
								name=
								"nontransactionalRead"
								value=
								"true"
								/>
								</bean>
								</beans>

You can also set up JDO PersistenceManagerFactoryin the JNDI environment of a Java EE application server, usually through the JCA connector provided by the particular JDO implementation. Spring’s standard JndiObjectFactoryBeanor <jee:jndi-lookup>can be used to retrieve and expose such a PersistenceManagerFactory. However, outside an EJB context, no real benefit exists in holding the PersistenceManagerFactoryin JNDI: only choose such a setup for a good reason. See Section 20.3.6, “Comparing container-managed and locally defined resources”for a discussion; the arguments there apply to JDO as well.

20.4.2 Implementing DAOs based on the plain JDO API

DAOs can also be written directly against plain JDO API, without any Spring dependencies, by using an injected PersistenceManagerFactory. The following is an example of a corresponding DAO implementation:

								public
								classProductDaoImpl
								implementsProductDao {
								privatePersistenceManagerFactory persistenceManagerFactory;
								public
								voidsetPersistenceManagerFactory(PersistenceManagerFactory pmf) {
								this.persistenceManagerFactory = pmf; }
								publicCollection loadProductsByCategory(String category) { PersistenceManager pm =
								this.persistenceManagerFactory.getPersistenceManager();
								try{ Query query = pm.newQuery(Product.
								class,
								"category = pCategory"); query.declareParameters(
								"String pCategory");
								returnquery.execute(category); }
								finally{ pm.close(); } } }
								<beans>
								<bean
								id=
								"myProductDao"
								class=
								"product.ProductDaoImpl"
								>
								<property
								name=
								"persistenceManagerFactory"
								ref=
								"myPmf"
								/>
								</bean>
								</beans>

The main problem with such DAOs is that they always get a new PersistenceManagerfrom the factory. To access a Spring-managed transactional PersistenceManager, define a TransactionAwarePersistenceManagerFactoryProxy(as included in Spring) in front of your target PersistenceManagerFactory, then passing a reference to that proxy into your DAOs as in the following example:

								<beans>
								<bean
								id=
								"myPmfProxy"
								class=
								"org.springframework.orm.jdo.TransactionAwarePersistenceManagerFactoryProxy"
								>
								<property
								name=
								"targetPersistenceManagerFactory"
								ref=
								"myPmf"
								/>
								</bean>
								<bean
								id=
								"myProductDao"
								class=
								"product.ProductDaoImpl"
								>
								<property
								name=
								"persistenceManagerFactory"
								ref=
								"myPmfProxy"
								/>
								</bean>
								</beans>

Your data access code will receive a transactional PersistenceManager(if any) from the PersistenceManagerFactory.getPersistenceManager()method that it calls. The latter method call goes through the proxy, which first checks for a current transactional PersistenceManagerbefore getting a new one from the factory. Any close()calls on the PersistenceManagerare ignored in case of a transactional PersistenceManager.

If your data access code always runs within an active transaction (or at least within active transaction synchronization), it is safe to omit the PersistenceManager.close()call and thus the entire finallyblock, which you might do to keep your DAO implementations concise:

								public
								classProductDaoImpl
								implementsProductDao {
								privatePersistenceManagerFactory persistenceManagerFactory;
								public
								voidsetPersistenceManagerFactory(PersistenceManagerFactory pmf) {
								this.persistenceManagerFactory = pmf; }
								publicCollection loadProductsByCategory(String category) { PersistenceManager pm =
								this.persistenceManagerFactory.getPersistenceManager(); Query query = pm.newQuery(Product.
								class,
								"category = pCategory"); query.declareParameters(
								"String pCategory");
								returnquery.execute(category); } }

With such DAOs that rely on active transactions, it is recommended that you enforce active transactions through turning off TransactionAwarePersistenceManagerFactoryProxy’s `allowCreateflag:

								<beans>
								<bean
								id=
								"myPmfProxy"
								class=
								"org.springframework.orm.jdo.TransactionAwarePersistenceManagerFactoryProxy"
								>
								<property
								name=
								"targetPersistenceManagerFactory"
								ref=
								"myPmf"
								/>
								<property
								name=
								"allowCreate"
								value=
								"false"
								/>
								</bean>
								<bean
								id=
								"myProductDao"
								class=
								"product.ProductDaoImpl"
								>
								<property
								name=
								"persistenceManagerFactory"
								ref=
								"myPmfProxy"
								/>
								</bean>
								</beans>

The main advantage of this DAO style is that it depends on JDO API only; no import of any Spring class is required. This is of course appealing from a non-invasiveness perspective, and might feel more natural to JDO developers.

However, the DAO throws plain JDOException(which is unchecked, so does not have to be declared or caught), which means that callers can only treat exceptions as fatal, unless you want to depend on JDO’s own exception structure. Catching specific causes such as an optimistic locking failure is not possible without tying the caller to the implementation strategy. This trade off might be acceptable to applications that are strongly JDO-based and/or do not need any special exception treatment.

In summary, you can DAOs based on the plain JDO API, and they can still participate in Spring-managed transactions. This strategy might appeal to you if you are already familiar with JDO. However, such DAOs throw plain JDOException, and you would have to convert explicitly to Spring’s DataAccessException(if desired).

20.4.3 Transaction management

[Note] Note

You are stronglyencouraged to read Section 17.5, “Declarative transaction management”if you have not done so, to get a more detailed coverage of Spring’s declarative transaction support.

To execute service operations within transactions, you can use Spring’s common declarative transaction facilities. For example:

								<?xml version="1.0" encoding="UTF-8"?>
								<beans
								xmlns=
								"http://www.springframework.org/schema/beans"
								xmlns:xsi=
								"http://www.w3.org/2001/XMLSchema-instance"
								xmlns:aop=
								"http://www.springframework.org/schema/aop"
								xmlns:tx=
								"http://www.springframework.org/schema/tx"
								xsi:schemaLocation=
								" http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd"
								>
								<bean
								id=
								"myTxManager"
								class=
								"org.springframework.orm.jdo.JdoTransactionManager"
								>
								<property
								name=
								"persistenceManagerFactory"
								ref=
								"myPmf"
								/>
								</bean>
								<bean
								id=
								"myProductService"
								class=
								"product.ProductServiceImpl"
								>
								<property
								name=
								"productDao"
								ref=
								"myProductDao"
								/>
								</bean>
								<tx:advice
								id=
								"txAdvice"
								transaction-manager=
								"txManager"
								>
								<tx:attributes>
								<tx:method
								name=
								"increasePrice*"
								propagation=
								"REQUIRED"
								/>
								<tx:method
								name=
								"someOtherBusinessMethod"
								propagation=
								"REQUIRES_NEW"
								/>
								<tx:method
								name=
								"*"
								propagation=
								"SUPPORTS"
								read-only=
								"true"
								/>
								</tx:attributes>
								</tx:advice>
								<aop:config>
								<aop:pointcut
								id=
								"productServiceMethods"
								expression=
								"execution(* product.ProductService.*(..))"
								/>
								<aop:advisor
								advice-ref=
								"txAdvice"
								pointcut-ref=
								"productServiceMethods"
								/>
								</aop:config>
								</beans>

JDO requires an active transaction to modify a persistent object. The non-transactional flush concept does not exist in JDO, in contrast to Hibernate. For this reason, you need to set up the chosen JDO implementation for a specific environment. Specifically, you need to set it up explicitly for JTA synchronization, to detect an active JTA transaction itself. This is not necessary for local transactions as performed by Spring’s JdoTransactionManager, but it is necessary to participate in JTA transactions, whether driven by Spring’s JtaTransactionManageror by EJB CMT and plain JTA.

JdoTransactionManageris capable of exposing a JDO transaction to JDBC access code that accesses the same JDBC DataSource, provided that the registered JdoDialectsupports retrieval of the underlying JDBC Connection. This is the case for JDBC-based JDO 2.0 implementations by default.

20.4.4 JdoDialect

As an advanced feature, both LocalPersistenceManagerFactoryBeanand JdoTransactionManagersupport a custom JdoDialectthat can be passed into the jdoDialectbean property. Using a JdoDialectimplementation, you can enable advanced features supported by Spring, usually in a vendor-specific manner:

  • Applying specific transaction semantics such as custom isolation level or transaction timeout
  • Retrieving the transactional JDBC Connectionfor exposure to JDBC-based DAOs
  • Applying query timeouts, which are automatically calculated from Spring-managed transaction timeouts
  • Eagerly flushing a PersistenceManager,to make transactional changes visible to JDBC-based data access code
  • Advanced translation of JDOExceptionsto Spring DataAccessExceptions

See the JdoDialectjavadocs for more details on its operations and how to use them within Spring’s JDO support.

20.5 JPA

The Spring JPA, available under the org.springframework.orm.jpapackage, offers comprehensive support for the Java Persistence APIin a similar manner to the integration with Hibernate or JDO, while being aware of the underlying implementation in order to provide additional features.

20.5.1 Three options for JPA setup in a Spring environment

The Spring JPA support offers three ways of setting up the JPA EntityManagerFactorythat will be used by the application to obtain an entity manager.

LocalEntityManagerFactoryBean

[Note] Note

Only use this option in simple deployment environments such as stand-alone applications and integration tests.

The LocalEntityManagerFactoryBeancreates an EntityManagerFactorysuitable for simple deployment environments where the application uses only JPA for data access. The factory bean uses the JPA PersistenceProviderautodetection mechanism (according to JPA’s Java SE bootstrapping) and, in most cases, requires you to specify only the persistence unit name:

									<beans>
									<bean
									id=
									"myEmf"
									class=
									"org.springframework.orm.jpa.LocalEntityManagerFactoryBean"
									>
									<property
									name=
									"persistenceUnitName"
									value=
									"myPersistenceUnit"
									/>
									</bean>
									</beans>

This form of JPA deployment is the simplest and the most limited. You cannot refer to an existing JDBC DataSourcebean definition and no support for global transactions exists. Furthermore, weaving (byte-code transformation) of persistent classes is provider-specific, often requiring a specific JVM agent to specified on startup. This option is sufficient only for stand-alone applications and test environments, for which the JPA specification is designed.

Obtaining an EntityManagerFactory from JNDI

[Note] Note

Use this option when deploying to a Java EE 5 server. Check your server’s documentation on how to deploy a custom JPA provider into your server, allowing for a different provider than the server’s default.

Obtaining an EntityManagerFactoryfrom JNDI (for example in a Java EE 5 environment), is simply a matter of changing the XML configuration:

									<beans>
									<jee:jndi-lookup
									id=
									"myEmf"
									jndi-name=
									"persistence/myPersistenceUnit"
									/>
									</beans>

This action assumes standard Java EE 5 bootstrapping: the Java EE server autodetects persistence units (in effect, META-INF/persistence.xmlfiles in application jars) and persistence-unit-refentries in the Java EE deployment descriptor (for example, web.xml) and defines environment naming context locations for those persistence units.

In such a scenario, the entire persistence unit deployment, including the weaving (byte-code transformation) of persistent classes, is up to the Java EE server. The JDBC DataSourceis defined through a JNDI location in the META-INF/persistence.xmlfile; EntityManager transactions are integrated with the server’s JTA subsystem. Spring merely uses the obtained EntityManagerFactory, passing it on to application objects through dependency injection, and managing transactions for the persistence unit, typically through JtaTransactionManager.

If multiple persistence units are used in the same application, the bean names of such JNDI-retrieved persistence units should match the persistence unit names that the application uses to refer to them, for example, in @PersistenceUnitand @PersistenceContextannotations.

LocalContainerEntityManagerFactoryBean

[Note] Note

Use this option for full JPA capabilities in a Spring-based application environment. This includes web containers such as Tomcat as well as stand-alone applications and integration tests with sophisticated persistence requirements.

The LocalContainerEntityManagerFactoryBeangives full control over EntityManagerFactoryconfiguration and is appropriate for environments where fine-grained customization is required. The LocalContainerEntityManagerFactoryBeancreates a PersistenceUnitInfoinstance based on the persistence.xmlfile, the supplied dataSourceLookupstrategy, and the specified loadTimeWeaver. It is thus possible to work with custom data sources outside of JNDI and to control the weaving process. The following example shows a typical bean definition for a LocalContainerEntityManagerFactoryBean:

									<beans>
									<bean
									id=
									"myEmf"
									class=
									"org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean"
									>
									<property
									name=
									"dataSource"
									ref=
									"someDataSource"
									/>
									<property
									name=
									"loadTimeWeaver"
									>
									<bean
									class=
									"org.springframework.instrument.classloading.InstrumentationLoadTimeWeaver"
									/>
									</property>
									</bean>
									</beans>

The following example shows a typical persistence.xmlfile:

									<persistence
									xmlns=
									"http://java.sun.com/xml/ns/persistence"
									version=
									"1.0"
									>
									<persistence-unit
									name=
									"myUnit"
									transaction-type=
									"RESOURCE_LOCAL"
									>
									<mapping-file>META-INF/orm.xml
									</mapping-file>
									<exclude-unlisted-classes/>
									</persistence-unit>
									</persistence>
[Note] Note

The <exclude-unlisted-classes/>shortcut indicates that noscanning for annotated entity classes is supposed to occur. An explicit 'true' value specified - <exclude-unlisted-classes>true</exclude-unlisted-classes/>- also means no scan. <exclude-unlisted-classes>false</exclude-unlisted-classes/>does trigger a scan; however, it is recommended to simply omit the exclude-unlisted-classeselement if you want entity class scanning to occur.

Using the LocalContainerEntityManagerFactoryBeanis the most powerful JPA setup option, allowing for flexible local configuration within the application. It supports links to an existing JDBC DataSource, supports both local and global transactions, and so on. However, it also imposes requirements on the runtime environment, such as the availability of a weaving-capable class loader if the persistence provider demands byte-code transformation.

This option may conflict with the built-in JPA capabilities of a Java EE 5 server. In a full Java EE 5 environment, consider obtaining your EntityManagerFactoryfrom JNDI. Alternatively, specify a custom persistenceXmlLocationon your LocalContainerEntityManagerFactoryBeandefinition, for example, META-INF/my-persistence.xml, and only include a descriptor with that name in your application jar files. Because the Java EE 5 server only looks for default META-INF/persistence.xmlfiles, it ignores such custom persistence units and hence avoid conflicts with a Spring-driven JPA setup upfront. (This applies to Resin 3.1, for example.)

When is load-time weaving required?

Not all JPA providers require a JVM agent ; Hibernate is an example of one that does not. If your provider does not require an agent or you have other alternatives, such as applying enhancements at build time through a custom compiler or an ant task, the load-time weaver should notbe used.

The LoadTimeWeaverinterface is a Spring-provided class that allows JPA ClassTransformerinstances to be plugged in a specific manner, depending whether the environment is a web container or application server. Hooking ClassTransformersthrough an agenttypically is not efficient. The agents work against the entire virtual machineand inspect everyclass that is loaded, which is usually undesirable in a production server environment.

Spring provides a number of LoadTimeWeaverimplementations for various environments, allowing ClassTransformerinstances to be applied only per class loaderand not per VM.

Refer to the section called “Spring configuration”in the AOP chapter for more insight regarding the LoadTimeWeaverimplementations and their setup, either generic or customized to various platforms (such as Tomcat, WebLogic, GlassFish, Resin and JBoss).

As described in the aforementioned section, you can configure a context-wide LoadTimeWeaverusing the @EnableLoadTimeWeavingannotation of context:load-time-weaverXML element. Such a global weaver is picked up by all JPA LocalContainerEntityManagerFactoryBeansautomatically. This is the preferred way of setting up a load-time weaver, delivering autodetection of the platform (WebLogic, GlassFish, Tomcat, Resin, JBoss or VM agent) and automatic propagation of the weaver to all weaver-aware beans:

									<context:load-time-weaver/>
									<bean
									id=
									"emf"
									class=
									"org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean"
									>...
									</bean>

However, if needed, one can manually specify a dedicated weaver through the loadTimeWeaverproperty:

									<bean
									id=
									"emf"
									class=
									"org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean"
									>
									<property
									name=
									"loadTimeWeaver"
									>
									<bean
									class=
									"org.springframework.instrument.classloading.ReflectiveLoadTimeWeaver"
									/>
									</property>
									</bean>

No matter how the LTW is configured, using this technique, JPA applications relying on instrumentation can run in the target platform (ex: Tomcat) without needing an agent. This is important especially when the hosting applications rely on different JPA implementations because the JPA transformers are applied only at class loader level and thus are isolated from each other.

Dealing with multiple persistence units

For applications that rely on multiple persistence units locations, stored in various JARS in the classpath, for example, Spring offers the PersistenceUnitManagerto act as a central repository and to avoid the persistence units discovery process, which can be expensive. The default implementation allows multiple locations to be specified that are parsed and later retrieved through the persistence unit name. (By default, the classpath is searched for META-INF/persistence.xmlfiles.)

									<bean
									id=
									"pum"
									class=
									"org.springframework.orm.jpa.persistenceunit.DefaultPersistenceUnitManager"
									>
									<property
									name=
									"persistenceXmlLocations"
									>
									<list>
									<value>org/springframework/orm/jpa/domain/persistence-multi.xml
									</value>
									<value>classpath:/my/package/**/custom-persistence.xml
									</value>
									<value>classpath*:META-INF/persistence.xml
									</value>
									</list>
									</property>
									<property
									name=
									"dataSources"
									>
									<map>
									<entry
									key=
									"localDataSource"
									value-ref=
									"local-db"
									/>
									<entry
									key=
									"remoteDataSource"
									value-ref=
									"remote-db"
									/>
									</map>
									</property>
									<!-- if no datasource is specified, use this one -->
									<property
									name=
									"defaultDataSource"
									ref=
									"remoteDataSource"
									/>
									</bean>
									<bean
									id=
									"emf"
									class=
									"org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean"
									>
									<property
									name=
									"persistenceUnitManager"
									ref=
									"pum"
									/>
									<property
									name=
									"persistenceUnitName"
									value=
									"myCustomUnit"
									/>
									</bean>

The default implementation allows customization of the PersistenceUnitInfoinstances, before they are fed to the JPA provider, declaratively through its properties, which affect allhosted units, or programmatically, through the PersistenceUnitPostProcessor, which allows persistence unit selection. If no PersistenceUnitManageris specified, one is created and used internally by LocalContainerEntityManagerFactoryBean.

20.5.2 Implementing DAOs based on plain JPA

[Note] Note

Although EntityManagerFactoryinstances are thread-safe, EntityManagerinstances are not. The injected JPA EntityManagerbehaves like an EntityManagerfetched from an application server’s JNDI environment, as defined by the JPA specification. It delegates all calls to the current transactional EntityManager, if any; otherwise, it falls back to a newly created EntityManagerper operation, in effect making its usage thread-safe.

It is possible to write code against the plain JPA without any Spring dependencies, by using an injected EntityManagerFactoryor EntityManager. Spring can understand @PersistenceUnitand @PersistenceContextannotations both at field and method level if a PersistenceAnnotationBeanPostProcessoris enabled. A plain JPA DAO implementation using the @PersistenceUnitannotation might look like this:

								public
								classProductDaoImpl
								implementsProductDao {
								privateEntityManagerFactory emf;
								
									@PersistenceUnit
								public
								voidsetEntityManagerFactory(EntityManagerFactory emf) {
								this.emf = emf; }
								publicCollection loadProductsByCategory(String category) { EntityManager em =
								this.emf.createEntityManager();
								try{ Query query = em.createQuery(
								"from Product as p where p.category = ?1"); query.setParameter(
								1, category);
								returnquery.getResultList(); }
								finally{
								if(em != null) { em.close(); } } } }

The DAO above has no dependency on Spring and still fits nicely into a Spring application context. Moreover, the DAO takes advantage of annotations to require the injection of the default EntityManagerFactory:

								<beans>
								<!-- bean post-processor for JPA annotations -->
								<bean
								class=
								"org.springframework.orm.jpa.support.PersistenceAnnotationBeanPostProcessor"
								/>
								<bean
								id=
								"myProductDao"
								class=
								"product.ProductDaoImpl"
								/>
								</beans>

As an alternative to defining a PersistenceAnnotationBeanPostProcessorexplicitly, consider using the Spring context:annotation-configXML element in your application context configuration. Doing so automatically registers all Spring standard post-processors for annotation-based configuration, including CommonAnnotationBeanPostProcessorand so on.

								<beans>
								<!-- post-processors for all standard config annotations -->
								<context:annotation-config/>
								<bean
								id=
								"myProductDao"
								class=
								"product.ProductDaoImpl"
								/>
								</beans>

The main problem with such a DAO is that it always creates a new EntityManagerthrough the factory. You can avoid this by requesting a transactional EntityManager(also called "shared EntityManager" because it is a shared, thread-safe proxy for the actual transactional EntityManager) to be injected instead of the factory:

								public
								classProductDaoImpl
								implementsProductDao {
								
									@PersistenceContext
								privateEntityManager em;
								publicCollection loadProductsByCategory(String category) { Query query = em.createQuery(
								"from Product as p where p.category = :category"); query.setParameter(
								"category", category);
								returnquery.getResultList(); } }

The @PersistenceContextannotation has an optional attribute type, which defaults to PersistenceContextType.TRANSACTION. This default is what you need to receive a shared EntityManager proxy. The alternative, PersistenceContextType.EXTENDED, is a completely different affair: This results in a so-called extended EntityManager, which is not thread-safeand hence must not be used in a concurrently accessed component such as a Spring-managed singleton bean. Extended EntityManagers are only supposed to be used in stateful components that, for example, reside in a session, with the lifecycle of the EntityManager not tied to a current transaction but rather being completely up to the application.

Method- and field-level Injection

Annotations that indicate dependency injections (such as @PersistenceUnitand @PersistenceContext) can be applied on field or methods inside a class, hence the expressions method-level injectionand field-level injection. Field-level annotations are concise and easier to use while method-level allows for further processing of the injected dependency. In both cases the member visibility (public, protected, private) does not matter.

What about class-level annotations?

On the Java EE 5 platform, they are used for dependency declaration and not for resource injection.

The injected EntityManageris Spring-managed (aware of the ongoing transaction). It is important to note that even though the new DAO implementation uses method level injection of an EntityManagerinstead of an EntityManagerFactory, no change is required in the application context XML due to annotation usage.

The main advantage of this DAO style is that it only depends on Java Persistence API; no import of any Spring class is required. Moreover, as the JPA annotations are understood, the injections are applied automatically by the Spring container. This is appealing from a non-invasiveness perspective, and might feel more natural to JPA developers.

20.5.3 Transaction Management

[Note] Note

You are stronglyencouraged to read Section 17.5, “Declarative transaction management”if you have not done so, to get a more detailed coverage of Spring’s declarative transaction support.

To execute service operations within transactions, you can use Spring’s common declarative transaction facilities. For example:

								<?xml version="1.0" encoding="UTF-8"?>
								<beans
								xmlns=
								"http://www.springframework.org/schema/beans"
								xmlns:xsi=
								"http://www.w3.org/2001/XMLSchema-instance"
								xmlns:aop=
								"http://www.springframework.org/schema/aop"
								xmlns:tx=
								"http://www.springframework.org/schema/tx"
								xsi:schemaLocation=
								" http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd"
								>
								<bean
								id=
								"myTxManager"
								class=
								"org.springframework.orm.jpa.JpaTransactionManager"
								>
								<property
								name=
								"entityManagerFactory"
								ref=
								"myEmf"
								/>
								</bean>
								<bean
								id=
								"myProductService"
								class=
								"product.ProductServiceImpl"
								>
								<property
								name=
								"productDao"
								ref=
								"myProductDao"
								/>
								</bean>
								<aop:config>
								<aop:pointcut
								id=
								"productServiceMethods"
								expression=
								"execution(* product.ProductService.*(..))"
								/>
								<aop:advisor
								advice-ref=
								"txAdvice"
								pointcut-ref=
								"productServiceMethods"
								/>
								</aop:config>
								<tx:advice
								id=
								"txAdvice"
								transaction-manager=
								"myTxManager"
								>
								<tx:attributes>
								<tx:method
								name=
								"increasePrice*"
								propagation=
								"REQUIRED"
								/>
								<tx:method
								name=
								"someOtherBusinessMethod"
								propagation=
								"REQUIRES_NEW"
								/>
								<tx:method
								name=
								"*"
								propagation=
								"SUPPORTS"
								read-only=
								"true"
								/>
								</tx:attributes>
								</tx:advice>
								</beans>

Spring JPA allows a configured JpaTransactionManagerto expose a JPA transaction to JDBC access code that accesses the same JDBC DataSource, provided that the registered JpaDialectsupports retrieval of the underlying JDBC Connection. Out of the box, Spring provides dialects for the EclipseLink, Hibernate and OpenJPA JPA implementations. See the next section for details on the JpaDialectmechanism.

20.5.4 JpaDialect

As an advanced feature JpaTransactionManagerand subclasses of AbstractEntityManagerFactoryBeansupport a custom JpaDialect, to be passed into the jpaDialectbean property. A JpaDialectimplementation can enable some advanced features supported by Spring, usually in a vendor-specific manner:

  • Applying specific transaction semantics such as custom isolation level or transaction timeout)
  • Retrieving the transactional JDBC Connectionfor exposure to JDBC-based DAOs)
  • Advanced translation of PersistenceExceptionsto Spring DataAccessExceptions

This is particularly valuable for special transaction semantics and for advanced translation of exception. The default implementation used ( DefaultJpaDialect) does not provide any special capabilities and if the above features are required, you have to specify the appropriate dialect.

See the JpaDialectjavadocs for more details of its operations and how they are used within Spring’s JPA support.

21. Marshalling XML using O/X Mappers

21.1 Introduction

In this chapter, we will describe Spring’s Object/XML Mapping support. Object/XML Mapping, or O/X mapping for short, is the act of converting an XML document to and from an object. This conversion process is also known as XML Marshalling, or XML Serialization. This chapter uses these terms interchangeably.

Within the field of O/X mapping, a marshalleris responsible for serializing an object (graph) to XML. In similar fashion, an unmarshallerdeserializes the XML to an object graph. This XML can take the form of a DOM document, an input or output stream, or a SAX handler.

Some of the benefits of using Spring for your O/X mapping needs are:

21.1.1 Ease of configuration

Spring’s bean factory makes it easy to configure marshallers, without needing to construct JAXB context, JiBX binding factories, etc. The marshallers can be configured as any other bean in your application context. Additionally, XML Schema-based configuration is available for a number of marshallers, making the configuration even simpler.

21.1.2 Consistent Interfaces

Spring’s O/X mapping operates through two global interfaces: the Marshallerand Unmarshallerinterface. These abstractions allow you to switch O/X mapping frameworks with relative ease, with little or no changes required on the classes that do the marshalling. This approach has the additional benefit of making it possible to do XML marshalling with a mix-and-match approach (e.g. some marshalling performed using JAXB, other using XMLBeans) in a non-intrusive fashion, leveraging the strength of each technology.

21.1.3 Consistent Exception Hierarchy

Spring provides a conversion from exceptions from the underlying O/X mapping tool to its own exception hierarchy with the XmlMappingExceptionas the root exception. As can be expected, these runtime exceptions wrap the original exception so no information is lost.

21.2 Marshaller and Unmarshaller

As stated in the introduction, a marshallerserializes an object to XML, and an unmarshallerdeserializes XML stream to an object. In this section, we will describe the two Spring interfaces used for this purpose.

21.2.1 Marshaller

Spring abstracts all marshalling operations behind the org.springframework.oxm.Marshallerinterface, the main methods of which is listed below.

								public
								interfaceMarshaller {
								/** * Marshals the object graph with the given root into the provided Result. */
								voidmarshal(Object graph, Result result)
								throwsXmlMappingException, IOException; }

The Marshallerinterface has one main method, which marshals the given object to a given javax.xml.transform.Result. Result is a tagging interface that basically represents an XML output abstraction: concrete implementations wrap various XML representations, as indicated in the table below.

Result implementation Wraps XML representation

DOMResult

org.w3c.dom.Node

SAXResult

org.xml.sax.ContentHandler

StreamResult

java.io.File, java.io.OutputStream, or java.io.Writer
[Note] Note

Although the marshal()method accepts a plain object as its first parameter, most Marshallerimplementations cannot handle arbitrary objects. Instead, an object class must be mapped in a mapping file, marked with an annotation, registered with the marshaller, or have a common base class. Refer to the further sections in this chapter to determine how your O/X technology of choice manages this.

21.2.2 Unmarshaller

Similar to the Marshaller, there is the org.springframework.oxm.Unmarshallerinterface.

								public
								interfaceUnmarshaller {
								/** * Unmarshals the given provided Source into an object graph. */Object unmarshal(Source source)
								throwsXmlMappingException, IOException; }

This interface also has one method, which reads from the given javax.xml.transform.Source(an XML input abstraction), and returns the object read. As with Result, Source is a tagging interface that has three concrete implementations. Each wraps a different XML representation, as indicated in the table below.

Source implementation Wraps XML representation

DOMSource

org.w3c.dom.Node

SAXSource

org.xml.sax.InputSource, and org.xml.sax.XMLReader

StreamSource

java.io.File, java.io.InputStream, or java.io.Reader

Even though there are two separate marshalling interfaces ( Marshallerand Unmarshaller), all implementations found in Spring-WS implement both in one class. This means that you can wire up one marshaller class and refer to it both as a marshaller and an unmarshaller in your applicationContext.xml.

21.2.3 XmlMappingException

Spring converts exceptions from the underlying O/X mapping tool to its own exception hierarchy with the XmlMappingExceptionas the root exception. As can be expected, these runtime exceptions wrap the original exception so no information will be lost.

Additionally, the MarshallingFailureExceptionand UnmarshallingFailureExceptionprovide a distinction between marshalling and unmarshalling operations, even though the underlying O/X mapping tool does not do so.

The O/X Mapping exception hierarchy is shown in the following figure:

oxm exceptions

O/X Mapping exception hierarchy

21.3 Using Marshaller and Unmarshaller

Spring’s OXM can be used for a wide variety of situations. In the following example, we will use it to marshal the settings of a Spring-managed application as an XML file. We will use a simple JavaBean to represent the settings:

							public
							classSettings {
							private
							booleanfooEnabled;
							public
							booleanisFooEnabled() {
							returnfooEnabled; }
							public
							voidsetFooEnabled(
							booleanfooEnabled) {
							this.fooEnabled = fooEnabled; } }

The application class uses this bean to store its settings. Besides a main method, the class has two methods: saveSettings()saves the settings bean to a file named settings.xml, and loadSettings()loads these settings again. A main()method constructs a Spring application context, and calls these two methods.

							importjava.io.FileInputStream;
							importjava.io.FileOutputStream;
							importjava.io.IOException;
							importjavax.xml.transform.stream.StreamResult;
							importjavax.xml.transform.stream.StreamSource;
							importorg.springframework.context.ApplicationContext;
							importorg.springframework.context.support.ClassPathXmlApplicationContext;
							importorg.springframework.oxm.Marshaller;
							importorg.springframework.oxm.Unmarshaller;
							public
							classApplication {
							private
							static
							finalString FILE_NAME =
							"settings.xml";
							privateSettings settings =
							newSettings();
							privateMarshaller marshaller;
							privateUnmarshaller unmarshaller;
							public
							voidsetMarshaller(Marshaller marshaller) {
							this.marshaller = marshaller; }
							public
							voidsetUnmarshaller(Unmarshaller unmarshaller) {
							this.unmarshaller = unmarshaller; }
							public
							voidsaveSettings()
							throwsIOException { FileOutputStream os = null;
							try{ os =
							newFileOutputStream(FILE_NAME);
							this.marshaller.marshal(settings,
							newStreamResult(os)); }
							finally{
							if(os != null) { os.close(); } } }
							public
							voidloadSettings()
							throwsIOException { FileInputStream is = null;
							try{ is =
							newFileInputStream(FILE_NAME);
							this.settings = (Settings)
							this.unmarshaller.unmarshal(
							newStreamSource(is)); }
							finally{
							if(is != null) { is.close(); } } }
							public
							static
							voidmain(String[] args)
							throwsIOException { ApplicationContext appContext =
							newClassPathXmlApplicationContext(
							"applicationContext.xml"); Application application = (Application) appContext.getBean(
							"application"); application.saveSettings(); application.loadSettings(); } }

The Applicationrequires both a marshallerand unmarshallerproperty to be set. We can do so using the following applicationContext.xml:

							<beans>
							<bean
							id=
							"application"
							class=
							"Application"
							>
							<property
							name=
							"marshaller"
							ref=
							"castorMarshaller"
							/>
							<property
							name=
							"unmarshaller"
							ref=
							"castorMarshaller"
							/>
							</bean>
							<bean
							id=
							"castorMarshaller"
							class=
							"org.springframework.oxm.castor.CastorMarshaller"
							/>
							</beans>

This application context uses Castor, but we could have used any of the other marshaller instances described later in this chapter. Note that Castor does not require any further configuration by default, so the bean definition is rather simple. Also note that the CastorMarshallerimplements both Marshallerand Unmarshaller, so we can refer to the castorMarshallerbean in both the marshallerand unmarshallerproperty of the application.

This sample application produces the following settings.xmlfile:

							<?xml version="1.0" encoding="UTF-8"?>
							<settings
							foo-enabled=
							"false"
							/>

21.4 XML Schema-based Configuration

Marshallers could be configured more concisely using tags from the OXM namespace. To make these tags available, the appropriate schema has to be referenced first in the preamble of the XML configuration file. Note the 'oxm' related text below:

							<?xml version="1.0" encoding="UTF-8"?>
							<beans
							xmlns=
							"http://www.springframework.org/schema/beans"
							xmlns:xsi=
							"http://www.w3.org/2001/XMLSchema-instance"
							
								xmlns:oxm="http://www.springframework.org/schema/oxm"xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
							
								http://www.springframework.org/schema/oxm http://www.springframework.org/schema/oxm/spring-oxm.xsd">

Currently, the following tags are available:

Each tag will be explained in its respective marshaller’s section. As an example though, here is how the configuration of a JAXB2 marshaller might look like:

							<oxm:jaxb2-marshaller
							id=
							"marshaller"
							contextPath=
							"org.springframework.ws.samples.airline.schema"
							/>

21.5 JAXB

The JAXB binding compiler translates a W3C XML Schema into one or more Java classes, a jaxb.propertiesfile, and possibly some resource files. JAXB also offers a way to generate a schema from annotated Java classes.

Spring supports the JAXB 2.0 API as XML marshalling strategies, following the Marshallerand Unmarshallerinterfaces described in Section 21.2, “Marshaller and Unmarshaller”. The corresponding integration classes reside in the org.springframework.oxm.jaxbpackage.

21.5.1 Jaxb2Marshaller

The Jaxb2Marshallerclass implements both the Spring Marshallerand Unmarshallerinterface. It requires a context path to operate, which you can set using the contextPathproperty. The context path is a list of colon (:) separated Java package names that contain schema derived classes. It also offers a classesToBeBoundproperty, which allows you to set an array of classes to be supported by the marshaller. Schema validation is performed by specifying one or more schema resource to the bean, like so:

								<beans>
								<bean
								id=
								"jaxb2Marshaller"
								class=
								"org.springframework.oxm.jaxb.Jaxb2Marshaller"
								>
								<property
								name=
								"classesToBeBound"
								>
								<list>
								<value>org.springframework.oxm.jaxb.Flight
								</value>
								<value>org.springframework.oxm.jaxb.Flights
								</value>
								</list>
								</property>
								<property
								name=
								"schema"
								value=
								"classpath:org/springframework/oxm/schema.xsd"
								/>
								</bean>...
								</beans>

XML Schema-based Configuration

The jaxb2-marshallertag configures a org.springframework.oxm.jaxb.Jaxb2Marshaller. Here is an example:

									<oxm:jaxb2-marshaller
									id=
									"marshaller"
									contextPath=
									"org.springframework.ws.samples.airline.schema"
									/>

Alternatively, the list of classes to bind can be provided to the marshaller via the class-to-be-boundchild tag:

									<oxm:jaxb2-marshaller
									id=
									"marshaller"
									>
									<oxm:class-to-be-bound
									name=
									"org.springframework.ws.samples.airline.schema.Airport"
									/>
									<oxm:class-to-be-bound
									name=
									"org.springframework.ws.samples.airline.schema.Flight"
									/>...
									</oxm:jaxb2-marshaller>

Available attributes are:

Attribute Description Required

id

the id of the marshaller

no

contextPath

the JAXB Context path

no

21.6 Castor

Castor XML mapping is an open source XML binding framework. It allows you to transform the data contained in a java object model into/from an XML document. By default, it does not require any further configuration, though a mapping file can be used to have more control over the behavior of Castor.

For more information on Castor, refer to the Castor web site . The Spring integration classes reside in the org.springframework.oxm.castorpackage.

21.6.1 CastorMarshaller

As with JAXB, the CastorMarshallerimplements both the Marshallerand Unmarshallerinterface. It can be wired up as follows:

								<beans>
								<bean
								id=
								"castorMarshaller"
								class=
								"org.springframework.oxm.castor.CastorMarshaller"
								/>...
								</beans>

21.6.2 Mapping

Although it is possible to rely on Castor’s default marshalling behavior, it might be necessary to have more control over it. This can be accomplished using a Castor mapping file. For more information, refer to Castor XML Mapping.

The mapping can be set using the mappingLocationresource property, indicated below with a classpath resource.

								<beans>
								<bean
								id=
								"castorMarshaller"
								class=
								"org.springframework.oxm.castor.CastorMarshaller"
								>
								<property
								name=
								"mappingLocation"
								value=
								"classpath:mapping.xml"
								/>
								</bean>
								</beans>

XML Schema-based Configuration

The castor-marshallertag configures a org.springframework.oxm.castor.CastorMarshaller. Here is an example:

									<oxm:castor-marshaller
									id=
									"marshaller"
									mapping-location=
									"classpath:org/springframework/oxm/castor/mapping.xml"
									/>

The marshaller instance can be configured in two ways, by specifying either the location of a mapping file (through the mapping-locationproperty), or by identifying Java POJOs (through the target-classor target-packageproperties) for which there exist corresponding XML descriptor classes. The latter way is usually used in conjunction with XML code generation from XML schemas.

Available attributes are:

Attribute Description Required

id

the id of the marshaller

no

encoding

the encoding to use for unmarshalling from XML

no

target-class

a Java class name for a POJO for which an XML class descriptor is available (as generated through code generation)

no

target-package

a Java package name that identifies a package that contains POJOs and their corresponding Castor XML descriptor classes (as generated through code generation from XML schemas)

no

mapping-location

location of a Castor XML mapping file

no

21.7 XMLBeans

XMLBeans is an XML binding tool that has full XML Schema support, and offers full XML Infoset fidelity. It takes a different approach to that of most other O/X mapping frameworks, in that all classes that are generated from an XML Schema are all derived from XmlObject, and contain XML binding information in them.

For more information on XMLBeans, refer to the XMLBeans web site . The Spring-WS integration classes reside in the org.springframework.oxm.xmlbeanspackage.

21.7.1 XmlBeansMarshaller

The XmlBeansMarshallerimplements both the Marshallerand Unmarshallerinterfaces. It can be configured as follows:

								<beans>
								<bean
								id=
								"xmlBeansMarshaller"
								class=
								"org.springframework.oxm.xmlbeans.XmlBeansMarshaller"
								/>...
								</beans>
[Note] Note

Note that the XmlBeansMarshallercan only marshal objects of type XmlObject, and not every java.lang.Object.

XML Schema-based Configuration

The xmlbeans-marshallertag configures a org.springframework.oxm.xmlbeans.XmlBeansMarshaller. Here is an example:

									<oxm:xmlbeans-marshaller
									id=
									"marshaller"
									/>

Available attributes are:

Attribute Description Required

id

the id of the marshaller

no

options

the bean name of the XmlOptions that is to be used for this marshaller. Typically a XmlOptionsFactoryBeandefinition

no

21.8 JiBX

The JiBX framework offers a solution similar to that which JDO provides for ORM: a binding definition defines the rules for how your Java objects are converted to or from XML. After preparing the binding and compiling the classes, a JiBX binding compiler enhances the class files, and adds code to handle converting instances of the classes from or to XML.

For more information on JiBX, refer to the JiBX web site . The Spring integration classes reside in the org.springframework.oxm.jibxpackage.

21.8.1 JibxMarshaller

The JibxMarshallerclass implements both the Marshallerand Unmarshallerinterface. To operate, it requires the name of the class to marshal in, which you can set using the targetClassproperty. Optionally, you can set the binding name using the bindingNameproperty. In the next sample, we bind the Flightsclass:

								<beans>
								<bean
								id=
								"jibxFlightsMarshaller"
								class=
								"org.springframework.oxm.jibx.JibxMarshaller"
								>
								<property
								name=
								"targetClass"
								>org.springframework.oxm.jibx.Flights
								</property>
								</bean>...
								</beans>

A JibxMarshalleris configured for a single class. If you want to marshal multiple classes, you have to configure multiple JibxMarshallers with different targetClassproperty values.

XML Schema-based Configuration

The jibx-marshallertag configures a org.springframework.oxm.jibx.JibxMarshaller. Here is an example:

									<oxm:jibx-marshaller
									id=
									"marshaller"
									target-class=
									"org.springframework.ws.samples.airline.schema.Flight"
									/>

Available attributes are:

Attribute Description Required

id

the id of the marshaller

no

target-class

the target class for this marshaller

yes

bindingName

the binding name used by this marshaller

no

21.9 XStream

XStream is a simple library to serialize objects to XML and back again. It does not require any mapping, and generates clean XML.

For more information on XStream, refer to the XStream web site . The Spring integration classes reside in the org.springframework.oxm.xstreampackage.

21.9.1 XStreamMarshaller

The XStreamMarshallerdoes not require any configuration, and can be configured in an application context directly. To further customize the XML, you can set an alias map, which consists of string aliases mapped to classes:

								<beans>
								<bean
								id=
								"xstreamMarshaller"
								class=
								"org.springframework.oxm.xstream.XStreamMarshaller"
								>
								<property
								name=
								"aliases"
								>
								<props>
								<prop
								key=
								"Flight"
								>org.springframework.oxm.xstream.Flight
								</prop>
								</props>
								</property>
								</bean>...
								</beans>
[Warning] Warning

By default, XStream allows for arbitrary classes to be unmarshalled, which can result in security vulnerabilities. As such, it is not recommended to use the XStreamMarshallerto unmarshal XML from external sources(i.e. the Web), as this can result in security vulnerabilities. If you do use the XStreamMarshallerto unmarshal XML from an external source, set the supportedClassesproperty on the XStreamMarshaller, like so:

												<bean
												id=
												"xstreamMarshaller"
												class=
												"org.springframework.oxm.xstream.XStreamMarshaller"
												>
												<property
												name=
												"supportedClasses"
												value=
												"org.springframework.oxm.xstream.Flight"
												/>...
												</bean>

This will make sure that only the registered classes are eligible for unmarshalling.

Additionally, you can register custom convertersto make sure that only your supported classes can be unmarshalled. You might want to add a CatchAllConverteras the last converter in the list, in addition to converters that explicitly support the domain classes that should be supported. As a result, default XStream converters with lower priorities and possible security vulnerabilities do not get invoked.
[Note] Note

Note that XStream is an XML serialization library, not a data binding library. Therefore, it has limited namespace support. As such, it is rather unsuitable for usage within Web services.

Part VI. The Web

This part of the reference documentation covers Spring Framework’s support for the presentation tier (and specifically web-based presentation tiers) including support for WebSocket-style messaging in web applications.

Spring Framework’s own web framework, Spring Web MVC, is covered in the first couple of chapters. Subsequent chapters are concerned with Spring Framework’s integration with other web technologies, such as JSF.

Following that is coverage of Spring Framework’s MVC portlet framework.

The section then concludes with comprehensive coverage of the Spring Framework Chapter 26, WebSocket Support (including Section 26.4, “STOMP Over WebSocket Messaging Architecture”).

22. Web MVC framework

22.1 Introduction to Spring Web MVC framework

The Spring Web model-view-controller (MVC) framework is designed around a DispatcherServletthat dispatches requests to handlers, with configurable handler mappings, view resolution, locale, time zone and theme resolution as well as support for uploading files. The default handler is based on the @Controllerand @RequestMappingannotations, offering a wide range of flexible handling methods. With the introduction of Spring 3.0, the @Controllermechanism also allows you to create RESTful Web sites and applications, through the @PathVariableannotation and other features.

"Open for extension…​" A key design principle in Spring Web MVC and in Spring in general is the " Open for extension, closed for modification" principle.

Some methods in the core classes of Spring Web MVC are marked final. As a developer you cannot override these methods to supply your own behavior. This has not been done arbitrarily, but specifically with this principle in mind.

For an explanation of this principle, refer to Expert Spring Web MVC and Web Flowby Seth Ladd and others; specifically see the section "A Look At Design," on page 117 of the first edition. Alternatively, see

You cannot add advice to final methods when you use Spring MVC. For example, you cannot add advice to the AbstractController.setSynchronizeOnSession()method. Refer to Section 11.6.1, “Understanding AOP proxies”for more information on AOP proxies and why you cannot add advice to final methods.

In Spring Web MVC you can use any object as a command or form-backing object; you do not need to implement a framework-specific interface or base class. Spring’s data binding is highly flexible: for example, it treats type mismatches as validation errors that can be evaluated by the application, not as system errors. Thus you do not need to duplicate your business objects' properties as simple, untyped strings in your form objects simply to handle invalid submissions, or to convert the Strings properly. Instead, it is often preferable to bind directly to your business objects.

Spring’s view resolution is extremely flexible. A Controlleris typically responsible for preparing a model Mapwith data and selecting a view name but it can also write directly to the response stream and complete the request. View name resolution is highly configurable through file extension or Accept header content type negotiation, through bean names, a properties file, or even a custom ViewResolverimplementation. The model (the M in MVC) is a Mapinterface, which allows for the complete abstraction of the view technology. You can integrate directly with template based rendering technologies such as JSP, Velocity and Freemarker, or directly generate XML, JSON, Atom, and many other types of content. The model Mapis simply transformed into an appropriate format, such as JSP request attributes, a Velocity template model.

22.1.1 Features of Spring Web MVC

Spring Web Flow

Spring Web Flow (SWF) aims to be the best solution for the management of web application page flow.

SWF integrates with existing frameworks like Spring MVC and JSF, in both Servlet and Portlet environments. If you have a business process (or processes) that would benefit from a conversational model as opposed to a purely request model, then SWF may be the solution.

SWF allows you to capture logical page flows as self-contained modules that are reusable in different situations, and as such is ideal for building web application modules that guide the user through controlled navigations that drive business processes.

For more information about SWF, consult the Spring Web Flow website.

Spring’s web module includes many unique web support features:

  • Clear separation of roles. Each role — controller, validator, command object, form object, model object, DispatcherServlet, handler mapping, view resolver, and so on — can be fulfilled by a specialized object.
  • Powerful and straightforward configuration of both framework and application classes as JavaBeans. This configuration capability includes easy referencing across contexts, such as from web controllers to business objects and validators.
  • Adaptability, non-intrusiveness, and flexibility.Define any controller method signature you need, possibly using one of the parameter annotations (such as @RequestParam, @RequestHeader, @PathVariable, and more) for a given scenario.
  • Reusable business code, no need for duplication. Use existing business objects as command or form objects instead of mirroring them to extend a particular framework base class.
  • Customizable binding and validation. Type mismatches as application-level validation errors that keep the offending value, localized date and number binding, and so on instead of String-only form objects with manual parsing and conversion to business objects.
  • Customizable handler mapping and view resolution. Handler mapping and view resolution strategies range from simple URL-based configuration, to sophisticated, purpose-built resolution strategies. Spring is more flexible than web MVC frameworks that mandate a particular technique.
  • Flexible model transfer. Model transfer with a name/value Mapsupports easy integration with any view technology.
  • Customizable locale, time zone and theme resolution, support for JSPs with or without Spring tag library, support for JSTL, support for Velocity without the need for extra bridges, and so on.
  • A simple yet powerful JSP tag library known as the Spring tag library that provides support for features such as data binding and themes. The custom tags allow for maximum flexibility in terms of markup code. For information on the tag library descriptor, see the appendix entitled Chapter 43, spring JSP Tag Library
  • A JSP form tag library, introduced in Spring 2.0, that makes writing forms in JSP pages much easier.For information on the tag library descriptor, see the appendix entitled Chapter 44, spring-form JSP Tag Library
  • Beans whose lifecycle is scoped to the current HTTP request or HTTP Session.This is not a specific feature of Spring MVC itself, but rather of the WebApplicationContextcontainer(s) that Spring MVC uses. These bean scopes are described in Section 7.5.4, “Request, session, global session, application, and WebSocket scopes”

22.1.2 Pluggability of other MVC implementations

Non-Spring MVC implementations are preferable for some projects. Many teams expect to leverage their existing investment in skills and tools, for example with JSF.

If you do not want to use Spring’s Web MVC, but intend to leverage other solutions that Spring offers, you can integrate the web MVC framework of your choice with Spring easily. Simply start up a Spring root application context through its ContextLoaderListener, and access it through its ServletContextattribute (or Spring’s respective helper method) from within any action object. No "plug-ins" are involved, so no dedicated integration is necessary. From the web layer’s point of view, you simply use Spring as a library, with the root application context instance as the entry point.

Your registered beans and Spring’s services can be at your fingertips even without Spring’s Web MVC. Spring does not compete with other web frameworks in this scenario. It simply addresses the many areas that the pure web MVC frameworks do not, from bean configuration to data access and transaction handling. So you can enrich your application with a Spring middle tier and/or data access tier, even if you just want to use, for example, the transaction abstraction with JDBC or Hibernate.

22.2 The DispatcherServlet

Spring’s web MVC framework is, like many other web MVC frameworks, request-driven, designed around a central Servlet that dispatches requests to controllers and offers other functionality that facilitates the development of web applications. Spring’s DispatcherServlethowever, does more than just that. It is completely integrated with the Spring IoC container and as such allows you to use every other feature that Spring has.

The request processing workflow of the Spring Web MVC DispatcherServletis illustrated in the following diagram. The pattern-savvy reader will recognize that the DispatcherServletis an expression of the "Front Controller" design pattern (this is a pattern that Spring Web MVC shares with many other leading web frameworks).

Figure 22.1. The request processing workflow in Spring Web MVC (high level)

mvc

The DispatcherServletis an actual Servlet(it inherits from the HttpServletbase class), and as such is declared in your web application. You need to map requests that you want the DispatcherServletto handle, by using a URL mapping. Here is a standard Java EE Servlet configuration in a Servlet 3.0+ environment:

							public
							classMyWebApplicationInitializer
							implementsWebApplicationInitializer {
							
								@Override
							public
							voidonStartup(ServletContext container) { ServletRegistration.Dynamic registration = container.addServlet(
							"example",
							newDispatcherServlet()); registration.setLoadOnStartup(
							1); registration.addMapping(
							"/example/*"); } }

In the preceding example, all requests starting with /examplewill be handled by the DispatcherServletinstance named example.

WebApplicationInitializeris an interface provided by Spring MVC that ensures your code-based configuration is detected and automatically used to initialize any Servlet 3 container. An abstract base class implementation of this interface named AbstractAnnotationConfigDispatcherServletInitializermakes it even easier to register the DispatcherServletby simply specifying its servlet mapping and listing configuration classes - it’s even the recommended way to set up your Spring MVC application. See Code-based Servlet container initializationfor more details.

The DispatcherServletis an actual Servlet(it inherits from the HttpServletbase class), and as such is declared in the web.xmlof your web application. You need to map requests that you want the DispatcherServletto handle, by using a URL mapping in the same web.xmlfile. This is standard Java EE Servlet configuration; the following example shows such a DispatcherServletdeclaration and mapping:

Below is the web.xmlequivalent of the above code based example:

							<web-app>
							<servlet>
							<servlet-name>example
							</servlet-name>
							<servlet-class>org.springframework.web.servlet.DispatcherServlet
							</servlet-class>
							<load-on-startup>1
							</load-on-startup>
							</servlet>
							<servlet-mapping>
							<servlet-name>example
							</servlet-name>
							<url-pattern>/example/*
							</url-pattern>
							</servlet-mapping>
							</web-app>

As detailed in Section 7.15, “Additional Capabilities of the ApplicationContext”, ApplicationContextinstances in Spring can be scoped. In the Web MVC framework, each DispatcherServlethas its own WebApplicationContext, which inherits all the beans already defined in the root WebApplicationContext. The root WebApplicationContextshould contain all the infrastructure beans that should be shared between your other contexts and Servlet instances. These inherited beans can be overridden in the servlet-specific scope, and you can define new scope-specific beans local to a given Servlet instance.

Figure 22.2. Typical context hierarchy in Spring Web MVC

mvc context hierarchy

Upon initialization of a DispatcherServlet, Spring MVC looks for a file named [servlet-name]-servlet.xmlin the WEB-INFdirectory of your web application and creates the beans defined there, overriding the definitions of any beans defined with the same name in the global scope.

Consider the following DispatcherServletServlet configuration (in the web.xmlfile):

							<web-app>
							<servlet>
							<servlet-name>
							
								golfing
							</servlet-name>
							<servlet-class>org.springframework.web.servlet.DispatcherServlet
							</servlet-class>
							<load-on-startup>1
							</load-on-startup>
							</servlet>
							<servlet-mapping>
							<servlet-name>
							
								golfing
							</servlet-name>
							<url-pattern>/golfing/*
							</url-pattern>
							</servlet-mapping>
							</web-app>

With the above Servlet configuration in place, you will need to have a file called /WEB-INF/golfing-servlet.xmlin your application; this file will contain all of your Spring Web MVC-specific components (beans). You can change the exact location of this configuration file through a Servlet initialization parameter (see below for details).

It is also possible to have just one root context for single DispatcherServlet scenarios.

Figure 22.3. Single root context in Spring Web MVC

mvc root context

This can be configured by setting an empty contextConfigLocation servlet init parameter, as shown below:

							<web-app>
							<context-param>
							<param-name>contextConfigLocation
							</param-name>
							<param-value>/WEB-INF/root-context.xml
							</param-value>
							</context-param>
							<servlet>
							<servlet-name>dispatcher
							</servlet-name>
							<servlet-class>org.springframework.web.servlet.DispatcherServlet
							</servlet-class>
							<init-param>
							<param-name>contextConfigLocation
							</param-name>
							<param-value>
							</param-value>
							</init-param>
							<load-on-startup>1
							</load-on-startup>
							</servlet>
							<servlet-mapping>
							<servlet-name>dispatcher
							</servlet-name>
							<url-pattern>/*
							</url-pattern>
							</servlet-mapping>
							<listener>
							<listener-class>org.springframework.web.context.ContextLoaderListener
							</listener-class>
							</listener>
							</web-app>

The WebApplicationContextis an extension of the plain ApplicationContextthat has some extra features necessary for web applications. It differs from a normal ApplicationContextin that it is capable of resolving themes (see Section 22.9, “Using themes”), and that it knows which Servlet it is associated with (by having a link to the ServletContext). The WebApplicationContextis bound in the ServletContext, and by using static methods on the RequestContextUtilsclass you can always look up the WebApplicationContextif you need access to it.

Note that we can achieve the same with java-based configurations:

							public
							classGolfingWebAppInitializer
							extendsAbstractAnnotationConfigDispatcherServletInitializer {
							
								@Override
							protectedClass<?>[] getRootConfigClasses() {
							// GolfingAppConfig defines beans that would be in root-context.xml
							return
							newClass[] { GolfingAppConfig.
							class}; }
							
								@Override
							protectedClass<?>[] getServletConfigClasses() {
							// GolfingWebConfig defines beans that would be in golfing-servlet.xml
							return
							newClass[] { GolfingWebConfig.
							class}; }
							
								@Override
							protectedString[] getServletMappings() {
							return
							newString[] {
							"/golfing/*"}; } }

22.2.1 Special Bean Types In the WebApplicationContext

The Spring DispatcherServletuses special beans to process requests and render the appropriate views. These beans are part of Spring MVC. You can choose which special beans to use by simply configuring one or more of them in the WebApplicationContext. However, you don’t need to do that initially since Spring MVC maintains a list of default beans to use if you don’t configure any. More on that in the next section. First see the table below listing the special bean types the DispatcherServletrelies on.

Table 22.1. Special bean types in the WebApplicationContext

Bean type Explanation

HandlerMapping

Maps incoming requests to handlers and a list of pre- and post-processors (handler interceptors) based on some criteria the details of which vary by HandlerMappingimplementation. The most popular implementation supports annotated controllers but other implementations exists as well.

HandlerAdapter

Helps the DispatcherServletto invoke a handler mapped to a request regardless of the handler is actually invoked. For example, invoking an annotated controller requires resolving various annotations. Thus the main purpose of a HandlerAdapteris to shield the DispatcherServletfrom such details.

HandlerExceptionResolver

Maps exceptions to views also allowing for more complex exception handling code.

ViewResolver

Resolves logical String-based view names to actual Viewtypes.

LocaleResolver& LocaleContextResolver

Resolves the locale a client is using and possibly their time zone, in order to be able to offer internationalized views

ThemeResolver

Resolves themes your web application can use, for example, to offer personalized layouts

MultipartResolver

Parses multi-part requests for example to support processing file uploads from HTML forms.

FlashMapManager

Stores and retrieves the "input" and the "output" FlashMapthat can be used to pass attributes from one request to another, usually across a redirect.

22.2.2 Default DispatcherServlet Configuration

As mentioned in the previous section for each special bean the DispatcherServletmaintains a list of implementations to use by default. This information is kept in the file DispatcherServlet.propertiesin the package org.springframework.web.servlet.

All special beans have some reasonable defaults of their own. Sooner or later though you’ll need to customize one or more of the properties these beans provide. For example it’s quite common to configure an InternalResourceViewResolversettings its prefixproperty to the parent location of view files.

Regardless of the details, the important concept to understand here is that once you configure a special bean such as an InternalResourceViewResolverin your WebApplicationContext, you effectively override the list of default implementations that would have been used otherwise for that special bean type. For example if you configure an InternalResourceViewResolver, the default list of ViewResolverimplementations is ignored.

In Section 22.16, “Configuring Spring MVC”you’ll learn about other options for configuring Spring MVC including MVC Java config and the MVC XML namespace both of which provide a simple starting point and assume little knowledge of how Spring MVC works. Regardless of how you choose to configure your application, the concepts explained in this section are fundamental should be of help to you.

22.2.3 DispatcherServlet Processing Sequence

After you set up a DispatcherServlet, and a request comes in for that specific DispatcherServlet, the DispatcherServletstarts processing the request as follows:

  • The WebApplicationContextis searched for and bound in the request as an attribute that the controller and other elements in the process can use. It is bound by default under the key DispatcherServlet.WEB_APPLICATION_CONTEXT_ATTRIBUTE.
  • The locale resolver is bound to the request to enable elements in the process to resolve the locale to use when processing the request (rendering the view, preparing data, and so on). If you do not need locale resolving, you do not need it.
  • The theme resolver is bound to the request to let elements such as views determine which theme to use. If you do not use themes, you can ignore it.
  • If you specify a multipart file resolver, the request is inspected for multiparts; if multiparts are found, the request is wrapped in a MultipartHttpServletRequestfor further processing by other elements in the process. See Section 22.10, “Spring’s multipart (file upload) support”for further information about multipart handling.
  • An appropriate handler is searched for. If a handler is found, the execution chain associated with the handler (preprocessors, postprocessors, and controllers) is executed in order to prepare a model or rendering.
  • If a model is returned, the view is rendered. If no model is returned, (may be due to a preprocessor or postprocessor intercepting the request, perhaps for security reasons), no view is rendered, because the request could already have been fulfilled.

Handler exception resolvers that are declared in the WebApplicationContextpick up exceptions that are thrown during processing of the request. Using these exception resolvers allows you to define custom behaviors to address exceptions.

The Spring DispatcherServletalso supports the return of the last-modification-date, as specified by the Servlet API. The process of determining the last modification date for a specific request is straightforward: the DispatcherServletlooks up an appropriate handler mapping and tests whether the handler that is found implements the LastModifiedinterface. If so, the value of the long getLastModified(request)method of the LastModifiedinterface is returned to the client.

You can customize individual DispatcherServletinstances by adding Servlet initialization parameters ( init-paramelements) to the Servlet declaration in the web.xmlfile. See the following table for the list of supported parameters.

Table 22.2. DispatcherServlet initialization parameters

Parameter Explanation

contextClass

Class that implements WebApplicationContext, which instantiates the context used by this Servlet. By default, the XmlWebApplicationContextis used.

contextConfigLocation

String that is passed to the context instance (specified by contextClass) to indicate where context(s) can be found. The string consists potentially of multiple strings (using a comma as a delimiter) to support multiple contexts. In case of multiple context locations with beans that are defined twice, the latest location takes precedence.

namespace

Namespace of the WebApplicationContext. Defaults to [servlet-name]-servlet.

22.3 Implementing Controllers

Controllers provide access to the application behavior that you typically define through a service interface. Controllers interpret user input and transform it into a model that is represented to the user by the view. Spring implements a controller in a very abstract way, which enables you to create a wide variety of controllers.

Spring 2.5 introduced an annotation-based programming model for MVC controllers that uses annotations such as @RequestMapping, @RequestParam, @ModelAttribute, and so on. This annotation support is available for both Servlet MVC and Portlet MVC. Controllers implemented in this style do not have to extend specific base classes or implement specific interfaces. Furthermore, they do not usually have direct dependencies on Servlet or Portlet APIs, although you can easily configure access to Servlet or Portlet facilities.

[Tip] Tip

Available in the spring-projects Org on Github, a number of web applications leverage the annotation support described in this section including MvcShowcase, MvcAjax, MvcBasic, PetClinic, PetCare, and others.

 
							
								@Controller
							public
							classHelloWorldController {
							
								@RequestMapping("/helloWorld")
							publicString helloWorld(Model model) { model.addAttribute(
							"message",
							"Hello World!");
							return
							"helloWorld"; } }

As you can see, the @Controllerand @RequestMappingannotations allow flexible method names and signatures. In this particular example the method accepts a Modeland returns a view name as a String, but various other method parameters and return values can be used as explained later in this section. @Controllerand @RequestMappingand a number of other annotations form the basis for the Spring MVC implementation. This section documents these annotations and how they are most commonly used in a Servlet environment.

22.3.1 Defining a controller with @Controller

The @Controllerannotation indicates that a particular class serves the role of a controller. Spring does not require you to extend any controller base class or reference the Servlet API. However, you can still reference Servlet-specific features if you need to.

The @Controllerannotation acts as a stereotype for the annotated class, indicating its role. The dispatcher scans such annotated classes for mapped methods and detects @RequestMappingannotations (see the next section).

You can define annotated controller beans explicitly, using a standard Spring bean definition in the dispatcher’s context. However, the @Controllerstereotype also allows for autodetection, aligned with Spring general support for detecting component classes in the classpath and auto-registering bean definitions for them.

To enable autodetection of such annotated controllers, you add component scanning to your configuration. Use the spring-contextschema as shown in the following XML snippet:

								<?xml version="1.0" encoding="UTF-8"?>
								<beans
								xmlns=
								"http://www.springframework.org/schema/beans"
								xmlns:xsi=
								"http://www.w3.org/2001/XMLSchema-instance"
								xmlns:p=
								"http://www.springframework.org/schema/p"
								xmlns:context=
								"http://www.springframework.org/schema/context"
								xsi:schemaLocation=
								" http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd"
								>
								<context:component-scan
								base-package=
								"org.springframework.samples.petclinic.web"
								/>
								<!-- ... -->
								</beans>

22.3.2 Mapping Requests With @RequestMapping

You use the @RequestMappingannotation to map URLs such as /appointmentsonto an entire class or a particular handler method. Typically the class-level annotation maps a specific request path (or path pattern) onto a form controller, with additional method-level annotations narrowing the primary mapping for a specific HTTP method request method ("GET", "POST", etc.) or an HTTP request parameter condition.

The following example from the Petcaresample shows a controller in a Spring MVC application that uses this annotation:

								
									@Controller
								
									@RequestMapping("/appointments")
								public
								classAppointmentsController {
								private
								finalAppointmentBook appointmentBook;
								
									@Autowired
								publicAppointmentsController(AppointmentBook appointmentBook) {
								this.appointmentBook = appointmentBook; }
								
									@RequestMapping(method = RequestMethod.GET)
								publicMap<String, Appointment> get() {
								returnappointmentBook.getAppointmentsForToday(); }
								
									@RequestMapping(path = "/{day}", method = RequestMethod.GET)
								publicMap<String, Appointment> getForDay(
								
									@PathVariable
								
									@DateTimeFormat(iso=ISO.DATE)Date day, Model model) {
								returnappointmentBook.getAppointmentsForDay(day); }
								
									@RequestMapping(path = "/new", method = RequestMethod.GET)
								publicAppointmentForm getNewForm() {
								return
								newAppointmentForm(); }
								
									@RequestMapping(method = RequestMethod.POST)
								publicString add(
								
									@ValidAppointmentForm appointment, BindingResult result) {
								if(result.hasErrors()) {
								return
								"appointments/new"; } appointmentBook.addAppointment(appointment);
								return
								"redirect:/appointments"; } }

In the above example, @RequestMappingis used in a number of places. The first usage is on the type (class) level, which indicates that all handler methods in this controller are relative to the /appointmentspath. The get()method has a further @RequestMappingrefinement: it only accepts GETrequests, meaning that an HTTP GETfor /appointmentsinvokes this method. The add()has a similar refinement, and the getNewForm()combines the definition of HTTP method and path into one, so that GETrequests for appointments/neware handled by that method.

The getForDay()method shows another usage of @RequestMapping: URI templates. (See the section called “URI Template Patterns”).

A @RequestMappingon the class level is not required. Without it, all paths are simply absolute, and not relative. The following example from the PetClinicsample application shows a multi-action controller using @RequestMapping:

								
									@Controller
								public
								classClinicController {
								private
								finalClinic clinic;
								
									@Autowired
								publicClinicController(Clinic clinic) {
								this.clinic = clinic; }
								
									@RequestMapping("/")
								public
								voidwelcomeHandler() { }
								
									@RequestMapping("/vets")
								publicModelMap vetsHandler() {
								return
								newModelMap(
								this.clinic.getVets()); } }

The above example does not specify GETvs. PUT, POST, and so forth, because @RequestMappingmaps all HTTP methods by default. Use @RequestMapping(method=GET)or @GetMappingto narrow the mapping.

Composed @RequestMapping Variants

Spring Framework 4.3 introduces the following method-level composedvariants of the @RequestMappingannotation that help to simplify mappings for common HTTP methods and better express the semantics of the annotated handler method. For example, a @GetMappingcan be read as a GET @RequestMapping.

  • @GetMapping
  • @PostMapping
  • @PutMapping
  • @DeleteMapping
  • @PatchMapping

The following example shows a modified version of the AppointmentsControllerfrom the previous section that has been simplified with composed @RequestMappingannotations.

									
										@Controller
									
										@RequestMapping("/appointments")
									public
									classAppointmentsController {
									private
									finalAppointmentBook appointmentBook;
									
										@Autowired
									publicAppointmentsController(AppointmentBook appointmentBook) {
									this.appointmentBook = appointmentBook; }
									
										@GetMapping
									publicMap<String, Appointment> get() {
									returnappointmentBook.getAppointmentsForToday(); }
									
										@GetMapping("/{day}")
									publicMap<String, Appointment> getForDay(
									
										@PathVariable
									
										@DateTimeFormat(iso=ISO.DATE)Date day, Model model) {
									returnappointmentBook.getAppointmentsForDay(day); }
									
										@GetMapping("/new")
									publicAppointmentForm getNewForm() {
									return
									newAppointmentForm(); }
									
										@PostMapping
									publicString add(
									
										@ValidAppointmentForm appointment, BindingResult result) {
									if(result.hasErrors()) {
									return
									"appointments/new"; } appointmentBook.addAppointment(appointment);
									return
									"redirect:/appointments"; } }

@Controller and AOP Proxying

In some cases a controller may need to be decorated with an AOP proxy at runtime. One example is if you choose to have @Transactionalannotations directly on the controller. When this is the case, for controllers specifically, we recommend using class-based proxying. This is typically the default choice with controllers. However if a controller must implement an interface that is not a Spring Context callback (e.g. InitializingBean, *Aware, etc), you may need to explicitly configure class-based proxying. For example with <tx:annotation-driven/>, change to <tx:annotation-driven proxy-target-class="true"/>.

New Support Classes for @RequestMapping methods in Spring MVC 3.1

Spring 3.1 introduced a new set of support classes for @RequestMappingmethods called RequestMappingHandlerMappingand RequestMappingHandlerAdapterrespectively. They are recommended for use and even required to take advantage of new features in Spring MVC 3.1 and going forward. The new support classes are enabled by default by the MVC namespace and the MVC Java config but must be configured explicitly if using neither. This section describes a few important differences between the old and the new support classes.

Prior to Spring 3.1, type and method-level request mappings were examined in two separate stages — a controller was selected first by the DefaultAnnotationHandlerMappingand the actual method to invoke was narrowed down second by the AnnotationMethodHandlerAdapter.

With the new support classes in Spring 3.1, the RequestMappingHandlerMappingis the only place where a decision is made about which method should process the request. Think of controller methods as a collection of unique endpoints with mappings for each method derived from type and method-level @RequestMappinginformation.

This enables some new possibilities. For once a HandlerInterceptoror a HandlerExceptionResolvercan now expect the Object-based handler to be a HandlerMethod, which allows them to examine the exact method, its parameters and associated annotations. The processing for a URL no longer needs to be split across different controllers.

There are also several things no longer possible:

  • Select a controller first with a SimpleUrlHandlerMappingor BeanNameUrlHandlerMappingand then narrow the method based on @RequestMappingannotations.
  • Rely on method names as a fall-back mechanism to disambiguate between two @RequestMappingmethods that don’t have an explicit path mapping URL path but otherwise match equally, e.g. by HTTP method. In the new support classes @RequestMappingmethods have to be mapped uniquely.
  • Have a single default method (without an explicit path mapping) with which requests are processed if no other controller method matches more concretely. In the new support classes if a matching method is not found a 404 error is raised.

The above features are still supported with the existing support classes. However to take advantage of new Spring MVC 3.1 features you’ll need to use the new support classes.

URI Template Patterns

URI templatescan be used for convenient access to selected parts of a URL in a @RequestMappingmethod.

A URI Template is a URI-like string, containing one or more variable names. When you substitute values for these variables, the template becomes a URI. The proposed RFCfor URI Templates defines how a URI is parameterized. For example, the URI Template http://www.example.com/users/{userId}contains the variable userId. Assigning the value fredto the variable yields http://www.example.com/users/fred.

In Spring MVC you can use the @PathVariableannotation on a method argument to bind it to the value of a URI template variable:

									
										@GetMapping("/owners/{ownerId}")
									publicString findOwner(
									
										@PathVariableString ownerId, Model model) { Owner owner = ownerService.findOwner(ownerId); model.addAttribute(
									"owner", owner);
									return
									"displayOwner"; }

The URI Template " /owners/{ownerId}`" specifies the variable name `ownerId. When the controller handles this request, the value of ownerIdis set to the value found in the appropriate part of the URI. For example, when a request comes in for /owners/fred, the value of ownerIdis fred.

[Tip] Tip

To process the @PathVariable annotation, Spring MVC needs to find the matching URI template variable by name. You can specify it in the annotation:

													
														@GetMapping("/owners/{ownerId}")
													publicString findOwner(
													
														@PathVariable("ownerId")String theOwner, Model model) {
													// implementation omitted}

Or if the URI template variable name matches the method argument name you can omit that detail. As long as your code is compiled with debugging information or the -parameterscompiler flag on Java 8, Spring MVC will match the method argument name to the URI template variable name:

													
														@GetMapping("/owners/{ownerId}")
													publicString findOwner(
													
														@PathVariableString ownerId, Model model) {
													// implementation omitted}

A method can have any number of @PathVariableannotations:

									
										@GetMapping("/owners/{ownerId}/pets/{petId}")
									publicString findPet(
									
										@PathVariableString ownerId,
									
										@PathVariableString petId, Model model) { Owner owner = ownerService.findOwner(ownerId); Pet pet = owner.getPet(petId); model.addAttribute(
									"pet", pet);
									return
									"displayPet"; }

When a @PathVariableannotation is used on a Map<String, String>argument, the map is populated with all URI template variables.

A URI template can be assembled from type and method level @RequestMappingannotations. As a result the findPet()method can be invoked with a URL such as /owners/42/pets/21.

									
										@Controller@RequestMapping(
									
										"/owners/{ownerId}")
									public
									classRelativePathUriTemplateController { @RequestMapping(
									
										"/pets/{petId}")
									public
									voidfindPet(
									
										@PathVariableString ownerId,
									
										@PathVariableString petId, Model model) {
									// implementation omitted} }

A @PathVariableargument can be of any simple typesuch as int, long, Date, etc. Spring automatically converts to the appropriate type or throws a TypeMismatchExceptionif it fails to do so. You can also register support for parsing additional data types. See the section called “Method Parameters And Type Conversion”and the section called “Customizing WebDataBinder initialization”.

URI Template Patterns with Regular Expressions

Sometimes you need more precision in defining URI template variables. Consider the URL "/spring-web/spring-web-3.0.5.jar". How do you break it down into multiple parts?

The @RequestMappingannotation supports the use of regular expressions in URI template variables. The syntax is {varName:regex}where the first part defines the variable name and the second - the regular expression. For example:

									
										@RequestMapping("/spring-web/{symbolicName:[a-z-]+}-{version:\\d\\.\\d\\.\\d}{extension:\\.[a-z]+}")
									public
									voidhandle(
									
										@PathVariableString version,
									
										@PathVariableString extension) {
									// ...}

Path Patterns

In addition to URI templates, the @RequestMappingannotation and all composed @RequestMappingvariants also support Ant-style path patterns (for example, /myPath/*.do). A combination of URI template variables and Ant-style globs is also supported (e.g. /owners/*/pets/{petId}).

Path Pattern Comparison

When a URL matches multiple patterns, a sort is used to find the most specific match.

A pattern with a lower count of URI variables and wild cards is considered more specific. For example /hotels/{hotel}/*has 1 URI variable and 1 wild card and is considered more specific than /hotels/{hotel}/**which as 1 URI variable and 2 wild cards.

If two patterns have the same count, the one that is longer is considered more specific. For example /foo/bar*is longer and considered more specific than /foo/*.

When two patterns have the same count and length, the pattern with fewer wild cards is considered more specific. For example /hotels/{hotel}is more specific than /hotels/*.

There are also some additional special rules:

  • The default mapping pattern /**is less specific than any other pattern. For example /api/{a}/{b}/{c}is more specific.
  • A prefix patternsuch as /public/**is less specific than any other pattern that doesn’t contain double wildcards. For example /public/path3/{a}/{b}/{c}is more specific.

For the full details see AntPatternComparatorin AntPathMatcher. Note that the PathMatcher can be customized (see Section 22.16.11, “Path Matching”in the section on configuring Spring MVC).

Path Patterns with Placeholders

Patterns in @RequestMappingannotations support ${…​}placeholders against local properties and/or system properties and environment variables. This may be useful in cases where the path a controller is mapped to may need to be customized through configuration. For more information on placeholders, see the javadocs of the PropertyPlaceholderConfigurerclass.

Suffix Pattern Matching

By default Spring MVC performs ".*"suffix pattern matching so that a controller mapped to /personis also implicitly mapped to /person.*. This makes it easy to request different representations of a resource through the URL path (e.g. /person.pdf, /person.xml).

Suffix pattern matching can be turned off or restricted to a set of path extensions explicitly registered for content negotiation purposes. This is generally recommended to minimize ambiguity with common request mappings such as /person/{id}where a dot might not represent a file extension, e.g. /person/joe@email.comvs /person/joe@email.com.json. Furthermore as explained in the note below suffix pattern matching as well as content negotiation may be used in some circumstances to attempt malicious attacks and there are good reasons to restrict them meaningfully.

See Section 22.16.11, “Path Matching”for suffix pattern matching configuration and also Section 22.16.6, “Content Negotiation”for content negotiation configuration.

Suffix Pattern Matching and RFD

Reflected file download (RFD) attack was first described in a paper by Trustwavein 2014. The attack is similar to XSS in that it relies on input (e.g. query parameter, URI variable) being reflected in the response. However instead of inserting JavaScript into HTML, an RFD attack relies on the browser switching to perform a download and treating the response as an executable script if double-clicked based on the file extension (e.g. .bat, .cmd).

In Spring MVC @ResponseBodyand ResponseEntitymethods are at risk because they can render different content types which clients can request including via URL path extensions. Note however that neither disabling suffix pattern matching nor disabling the use of path extensions for content negotiation purposes alone are effective at preventing RFD attacks.

For comprehensive protection against RFD, prior to rendering the response body Spring MVC adds a Content-Disposition:inline;filename=f.txtheader to suggest a fixed and safe download file filename. This is done only if the URL path contains a file extension that is neither whitelisted nor explicitly registered for content negotiation purposes. However it may potentially have side effects when URLs are typed directly into a browser.

Many common path extensions are whitelisted by default. Furthermore REST API calls are typically not meant to be used as URLs directly in browsers. Nevertheless applications that use custom HttpMessageConverterimplementations can explicitly register file extensions for content negotiation and the Content-Disposition header will not be added for such extensions. See Section 22.16.6, “Content Negotiation”.

[Note] Note

This was originally introduced as part of work for CVE-2015-5211. Below are additional recommendations from the report:

  • Encode rather than escape JSON responses. This is also an OWASP XSS recommendation. For an example of how to do that with Spring see spring-jackson-owasp.
  • Configure suffix pattern matching to be turned off or restricted to explicitly registered suffixes only.
  • Configure content negotiation with the properties "useJaf" and "ignoreUnknownPathExtensions" set to false which would result in a 406 response for URLs with unknown extensions. Note however that this may not be an option if URLs are naturally expected to have a dot towards the end.
  • Add X-Content-Type-Options: nosniffheader to responses. Spring Security 4 does this by default.

Matrix Variables

The URI specification RFC 3986defines the possibility of including name-value pairs within path segments. There is no specific term used in the spec. The general "URI path parameters" could be applied although the more unique "Matrix URIs", originating from an old post by Tim Berners-Lee, is also frequently used and fairly well known. Within Spring MVC these are referred to as matrix variables.

Matrix variables can appear in any path segment, each matrix variable separated with a ";" (semicolon). For example: "/cars;color=red;year=2012". Multiple values may be either "," (comma) separated "color=red,green,blue"or the variable name may be repeated "color=red;color=green;color=blue".

If a URL is expected to contain matrix variables, the request mapping pattern must represent them with a URI template. This ensures the request can be matched correctly regardless of whether matrix variables are present or not and in what order they are provided.

Below is an example of extracting the matrix variable "q":

									// GET /pets/42;q=11;r=22
									
										@GetMapping("/pets/{petId}")
									public
									voidfindPet(
									
										@PathVariableString petId,
									
										@MatrixVariable
									intq) {
									// petId == 42
									// q == 11}

Since all path segments may contain matrix variables, in some cases you need to be more specific to identify where the variable is expected to be:

									// GET /owners/42;q=11/pets/21;q=22
									
										@GetMapping("/owners/{ownerId}/pets/{petId}")
									public
									voidfindPet(
									
										@MatrixVariable(name="q", pathVar="ownerId")
									intq1,
									
										@MatrixVariable(name="q", pathVar="petId")
									intq2) {
									// q1 == 11
									// q2 == 22}

A matrix variable may be defined as optional and a default value specified:

									// GET /pets/42
									
										@GetMapping("/pets/{petId}")
									public
									voidfindPet(
									
										@MatrixVariable(required=false, defaultValue="1")
									intq) {
									// q == 1}

All matrix variables may be obtained in a Map:

									// GET /owners/42;q=11;r=12/pets/21;q=22;s=23
									
										@GetMapping("/owners/{ownerId}/pets/{petId}")
									public
									voidfindPet(
									
										@MatrixVariableMultiValueMap<String, String> matrixVars,
									
										@MatrixVariable(pathVar="petId"")MultiValueMap<String, String> petMatrixVars) {
									// matrixVars: ["q" : [11,22], "r" : 12, "s" : 23]
									// petMatrixVars: ["q" : 11, "s" : 23]}

Note that to enable the use of matrix variables, you must set the removeSemicolonContentproperty of RequestMappingHandlerMappingto false. By default it is set to true.

[Tip] Tip

The MVC Java config and the MVC namespace both provide options for enabling the use of matrix variables.

If you are using Java config, The Advanced Customizations with MVC Java Configsection describes how the RequestMappingHandlerMappingcan be customized.

In the MVC namespace, the <mvc:annotation-driven>element has an enable-matrix-variablesattribute that should be set to true. By default it is set to false.

													<?xml version="1.0" encoding="UTF-8"?>
													<beans
													xmlns=
													"http://www.springframework.org/schema/beans"
													xmlns:mvc=
													"http://www.springframework.org/schema/mvc"
													xmlns:xsi=
													"http://www.w3.org/2001/XMLSchema-instance"
													xsi:schemaLocation=
													" http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc.xsd"
													>
													<mvc:annotation-driven
													enable-matrix-variables=
													"true"
													/>
													</beans>

Consumable Media Types

You can narrow the primary mapping by specifying a list of consumable media types. The request will be matched only if the Content-Typerequest header matches the specified media type. For example:

@PostMapping(path =
									"/pets",
									
										consumes = "application/json")
									public
									voidaddPet(
									
										@RequestBodyPet pet, Model model) {
									// implementation omitted}

Consumable media type expressions can also be negated as in !text/plainto match to all requests other than those with Content-Typeof text/plain. Also consider using constants provided in MediaTypesuch as APPLICATION_JSON_VALUEand APPLICATION_JSON_UTF8_VALUE.

[Tip] Tip

The consumescondition is supported on the type and on the method level. Unlike most other conditions, when used at the type level, method-level consumable types override rather than extend type-level consumable types.

Producible Media Types

You can narrow the primary mapping by specifying a list of producible media types. The request will be matched only if the Acceptrequest header matches one of these values. Furthermore, use of the producescondition ensures the actual content type used to generate the response respects the media types specified in the producescondition. For example:

@GetMapping(path =
									"/pets/{petId}",
									
										produces = MediaType.APPLICATION_JSON_UTF8_VALUE)
									
										@ResponseBody
									publicPet getPet(
									
										@PathVariableString petId, Model model) {
									// implementation omitted}
[Note] Note

Be aware that the media type specified in the producescondition can also optionally specify a character set. For example, in the code snippet above we specify the same media type than the default one configured in MappingJackson2HttpMessageConverter, including the UTF-8charset.

Just like with consumes, producible media type expressions can be negated as in !text/plainto match to all requests other than those with an Acceptheader value of text/plain. Also consider using constants provided in MediaTypesuch as APPLICATION_JSON_VALUEand APPLICATION_JSON_UTF8_VALUE.

[Tip] Tip

The producescondition is supported on the type and on the method level. Unlike most other conditions, when used at the type level, method-level producible types override rather than extend type-level producible types.

Request Parameters and Header Values

You can narrow request matching through request parameter conditions such as "myParam", "!myParam", or "myParam=myValue". The first two test for request parameter presence/absence and the third for a specific parameter value. Here is an example with a request parameter value condition:

									
										@Controller
									
										@RequestMapping("/owners/{ownerId}")
									public
									classRelativePathUriTemplateController { @GetMapping(path =
									"/pets/{petId}",
									
										params = "myParam=myValue")
									public
									voidfindPet(
									
										@PathVariableString ownerId,
									
										@PathVariableString petId, Model model) {
									// implementation omitted} }

The same can be done to test for request header presence/absence or to match based on a specific request header value:

									
										@Controller
									
										@RequestMapping("/owners/{ownerId}")
									public
									classRelativePathUriTemplateController { @GetMapping(path =
									"/pets",
									
										headers = "myHeader=myValue")
									public
									voidfindPet(
									
										@PathVariableString ownerId,
									
										@PathVariableString petId, Model model) {
									// implementation omitted} }
[Tip] Tip

Although you can match to Content-Typeand Acceptheader values using media type wild cards (for example "content-type=text/*"will match to "text/plain"and "text/html"), it is recommended to use the consumesand producesconditions respectively instead. They are intended specifically for that purpose.

HTTP HEAD and HTTP OPTIONS

@RequestMappingmethods mapped to "GET" are also implicitly mapped to "HEAD", i.e. there is no need to have "HEAD" explicitly declared. An HTTP HEAD request is processed as if it were an HTTP GET except instead of writing the body only the number of bytes are counted and the "Content-Length" header set.

@RequestMappingmethods have built-in support for HTTP OPTIONS. By default an HTTP OPTIONS request is handled by setting the "Allow" response header to the HTTP methods explicitly declared on all @RequestMappingmethods with matching URL patterns. When no HTTP methods are explicitly declared the "Allow" header is set to "GET,HEAD,POST,PUT,PATCH,DELETE,OPTIONS". Ideally always declare the HTTP method(s) that an @RequestMappingmethod is intended to handle, or alternatively use one of the dedicated composed @RequestMappingvariants (see the section called “Composed @RequestMapping Variants”).

Although not necessary an @RequestMappingmethod can be mapped to and handle either HTTP HEAD or HTTP OPTIONS, or both.

22.3.3 Defining @RequestMapping handler methods

@RequestMappinghandler methods can have very flexible signatures. The supported method arguments and return values are described in the following section. Most arguments can be used in arbitrary order with the only exception being BindingResultarguments. This is described in the next section.

[Note] Note

Spring 3.1 introduced a new set of support classes for @RequestMappingmethods called RequestMappingHandlerMappingand RequestMappingHandlerAdapterrespectively. They are recommended for use and even required to take advantage of new features in Spring MVC 3.1 and going forward. The new support classes are enabled by default from the MVC namespace and with use of the MVC Java config but must be configured explicitly if using neither.

Supported method argument types

The following are the supported method arguments:

  • Request or response objects (Servlet API). Choose any specific request or response type, for example ServletRequestor HttpServletRequest.
  • Session object (Servlet API): of type HttpSession. An argument of this type enforces the presence of a corresponding session. As a consequence, such an argument is never null.
[Note] Note

Session access may not be thread-safe, in particular in a Servlet environment. Consider setting the RequestMappingHandlerAdapter's "synchronizeOnSession" flag to "true" if multiple requests are allowed to access a session concurrently.
  • org.springframework.web.context.request.WebRequestor org.springframework.web.context.request.NativeWebRequest. Allows for generic request parameter access as well as request/session attribute access, without ties to the native Servlet/Portlet API.
  • java.util.Localefor the current request locale, determined by the most specific locale resolver available, in effect, the configured LocaleResolver/ LocaleContextResolverin an MVC environment.
  • java.util.TimeZone(Java 6+) / java.time.ZoneId(on Java 8) for the time zone associated with the current request, as determined by a LocaleContextResolver.
  • java.io.InputStream/ java.io.Readerfor access to the request’s content. This value is the raw InputStream/Reader as exposed by the Servlet API.
  • java.io.OutputStream/ java.io.Writerfor generating the response’s content. This value is the raw OutputStream/Writer as exposed by the Servlet API.
  • org.springframework.http.HttpMethodfor the HTTP request method.
  • java.security.Principalcontaining the currently authenticated user.
  • @PathVariableannotated parameters for access to URI template variables. See the section called “URI Template Patterns”.
  • @MatrixVariableannotated parameters for access to name-value pairs located in URI path segments. See the section called “Matrix Variables”.
  • @RequestParamannotated parameters for access to specific Servlet request parameters. Parameter values are converted to the declared method argument type. See the section called “Binding request parameters to method parameters with @RequestParam”.
  • @RequestHeaderannotated parameters for access to specific Servlet request HTTP headers. Parameter values are converted to the declared method argument type. See the section called “Mapping request header attributes with the @RequestHeader annotation”.
  • @RequestBodyannotated parameters for access to the HTTP request body. Parameter values are converted to the declared method argument type using HttpMessageConverters. See the section called “Mapping the request body with the @RequestBody annotation”.
  • @RequestPartannotated parameters for access to the content of a "multipart/form-data" request part. See Section 22.10.5, “Handling a file upload request from programmatic clients”and Section 22.10, “Spring’s multipart (file upload) support”.
  • @SessionAttributeannotated parameters for access to existing, permanent session attributes (e.g. user authentication object) as opposed to model attributes temporarily stored in the session as part of a controller workflow via @SessionAttributes.
  • @RequestAttributeannotated parameters for access to request attributes.
  • HttpEntity<?>parameters for access to the Servlet request HTTP headers and contents. The request stream will be converted to the entity body using HttpMessageConverters. See the section called “Using HttpEntity”.
  • java.util.Map/ org.springframework.ui.Model/ org.springframework.ui.ModelMapfor enriching the implicit model that is exposed to the web view.
  • org.springframework.web.servlet.mvc.support.RedirectAttributesto specify the exact set of attributes to use in case of a redirect and also to add flash attributes (attributes stored temporarily on the server-side to make them available to the request after the redirect). See the section called “Passing Data To the Redirect Target”and Section 22.6, “Using flash attributes”.
  • Command or form objects to bind request parameters to bean properties (via setters) or directly to fields, with customizable type conversion, depending on @InitBindermethods and/or the HandlerAdapter configuration. See the webBindingInitializerproperty on RequestMappingHandlerAdapter. Such command objects along with their validation results will be exposed as model attributes by default, using the command class name - e.g. model attribute "orderAddress" for a command object of type "some.package.OrderAddress". The ModelAttributeannotation can be used on a method argument to customize the model attribute name used.
  • org.springframework.validation.Errors/ org.springframework.validation.BindingResultvalidation results for a preceding command or form object (the immediately preceding method argument).
  • org.springframework.web.bind.support.SessionStatusstatus handle for marking form processing as complete, which triggers the cleanup of session attributes that have been indicated by the @SessionAttributesannotation at the handler type level.
  • org.springframework.web.util.UriComponentsBuildera builder for preparing a URL relative to the current request’s host, port, scheme, context path, and the literal part of the servlet mapping.

The Errorsor BindingResultparameters have to follow the model object that is being bound immediately as the method signature might have more than one model object and Spring will create a separate BindingResultinstance for each of them so the following sample won’t work:

Invalid ordering of BindingResult and @ModelAttribute.  

									
										@PostMapping
									publicString processSubmit(
									
										@ModelAttribute("pet") Pet pet, Model model,
									
										BindingResult result) { ... }

Note, that there is a Modelparameter in between Petand BindingResult. To get this working you have to reorder the parameters as follows:

									
										@PostMapping
									publicString processSubmit(
									
										@ModelAttribute("pet") Pet pet,
									
										BindingResult result, Model model) { ... }
[Note] Note

JDK 1.8’s java.util.Optionalis supported as a method parameter type with annotations that have a requiredattribute (e.g. @RequestParam, @RequestHeader, etc. The use of java.util.Optionalin those cases is equivalent to having required=false.

Supported method return types

The following are the supported return types:

  • A ModelAndViewobject, with the model implicitly enriched with command objects and the results of @ModelAttributeannotated reference data accessor methods.
  • A Modelobject, with the view name implicitly determined through a RequestToViewNameTranslatorand the model implicitly enriched with command objects and the results of @ModelAttributeannotated reference data accessor methods.
  • A Mapobject for exposing a model, with the view name implicitly determined through a RequestToViewNameTranslatorand the model implicitly enriched with command objects and the results of @ModelAttributeannotated reference data accessor methods.
  • A Viewobject, with the model implicitly determined through command objects and @ModelAttributeannotated reference data accessor methods. The handler method may also programmatically enrich the model by declaring a Modelargument (see above).
  • A Stringvalue that is interpreted as the logical view name, with the model implicitly determined through command objects and @ModelAttributeannotated reference data accessor methods. The handler method may also programmatically enrich the model by declaring a Modelargument (see above).
  • voidif the method handles the response itself (by writing the response content directly, declaring an argument of type ServletResponse/ HttpServletResponsefor that purpose) or if the view name is supposed to be implicitly determined through a RequestToViewNameTranslator(not declaring a response argument in the handler method signature).
  • If the method is annotated with @ResponseBody, the return type is written to the response HTTP body. The return value will be converted to the declared method argument type using HttpMessageConverters. See the section called “Mapping the response body with the @ResponseBody annotation”.
  • An HttpEntity<?>or ResponseEntity<?>object to provide access to the Servlet response HTTP headers and contents. The entity body will be converted to the response stream using HttpMessageConverters. See the section called “Using HttpEntity”.
  • An HttpHeadersobject to return a response with no body.
  • A Callable<?>can be returned when the application wants to produce the return value asynchronously in a thread managed by Spring MVC.
  • A DeferredResult<?>can be returned when the application wants to produce the return value from a thread of its own choosing.
  • A ListenableFuture<?>can be returned when the application wants to produce the return value from a thread of its own choosing.
  • A ResponseBodyEmittercan be returned to write multiple objects to the response asynchronously; also supported as the body within a ResponseEntity.
  • An SseEmittercan be returned to write Server-Sent Events to the response asynchronously; also supported as the body within a ResponseEntity.
  • A StreamingResponseBodycan be returned to write to the response OutputStream asynchronously; also supported as the body within a ResponseEntity.
  • Any other return type is considered to be a single model attribute to be exposed to the view, using the attribute name specified through @ModelAttributeat the method level (or the default attribute name based on the return type class name). The model is implicitly enriched with command objects and the results of @ModelAttributeannotated reference data accessor methods.

Binding request parameters to method parameters with @RequestParam

Use the @RequestParamannotation to bind request parameters to a method parameter in your controller.

The following code snippet shows the usage:

									
										@Controller
									
										@RequestMapping("/pets")
									
										@SessionAttributes("pet")
									public
									classEditPetForm {
									// ...
									
										@GetMapping
									publicString setupForm(
									
										@RequestParam("petId") int petId, ModelMap model) { Pet pet =
									this.clinic.loadPet(petId); model.addAttribute(
									"pet", pet);
									return
									"petForm"; }
									// ...}

Parameters using this annotation are required by default, but you can specify that a parameter is optional by setting @RequestParam's requiredattribute to false(e.g., @RequestParam(name="id", required=false)).

Type conversion is applied automatically if the target method parameter type is not String. See the section called “Method Parameters And Type Conversion”.

When an @RequestParamannotation is used on a Map<String, String>or MultiValueMap<String, String>argument, the map is populated with all request parameters.

Mapping the request body with the @RequestBody annotation

The @RequestBodymethod parameter annotation indicates that a method parameter should be bound to the value of the HTTP request body. For example:

									
										@PutMapping("/something")
									public
									voidhandle(
									
										@RequestBodyString body, Writer writer)
									throwsIOException { writer.write(body); }

You convert the request body to the method argument by using an HttpMessageConverter. HttpMessageConverteris responsible for converting from the HTTP request message to an object and converting from an object to the HTTP response body. The RequestMappingHandlerAdaptersupports the @RequestBodyannotation with the following default HttpMessageConverters:

  • ByteArrayHttpMessageConverterconverts byte arrays.
  • StringHttpMessageConverterconverts strings.
  • FormHttpMessageConverterconverts form data to/from a MultiValueMap<String, String>.
  • SourceHttpMessageConverterconverts to/from a javax.xml.transform.Source.

For more information on these converters, see Message Converters. Also note that if using the MVC namespace or the MVC Java config, a wider range of message converters are registered by default. See Section 22.16.1, “Enabling the MVC Java Config or the MVC XML Namespace”for more information.

If you intend to read and write XML, you will need to configure the MarshallingHttpMessageConverterwith a specific Marshallerand an Unmarshallerimplementation from the org.springframework.oxmpackage. The example below shows how to do that directly in your configuration but if your application is configured through the MVC namespace or the MVC Java config see Section 22.16.1, “Enabling the MVC Java Config or the MVC XML Namespace”instead.

									<bean
									class=
									"org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter"
									>
									<property
									name=
									"messageConverters"
									>
									<util:list
									id=
									"beanList"
									>
									<ref
									bean=
									"stringHttpMessageConverter"
									/>
									<ref
									bean=
									"marshallingHttpMessageConverter"
									/>
									</util:list>
									</property </bean>
									<bean
									id=
									"stringHttpMessageConverter"
									class=
									"org.springframework.http.converter.StringHttpMessageConverter"
									/>
									<bean
									id=
									"marshallingHttpMessageConverter"
									class=
									"org.springframework.http.converter.xml.MarshallingHttpMessageConverter"
									>
									<property
									name=
									"marshaller"
									ref=
									"castorMarshaller"
									/>
									<property
									name=
									"unmarshaller"
									ref=
									"castorMarshaller"
									/>
									</bean>
									<bean
									id=
									"castorMarshaller"
									class=
									"org.springframework.oxm.castor.CastorMarshaller"
									/>

An @RequestBodymethod parameter can be annotated with @Valid, in which case it will be validated using the configured Validatorinstance. When using the MVC namespace or the MVC Java config, a JSR-303 validator is configured automatically assuming a JSR-303 implementation is available on the classpath.

Just like with @ModelAttributeparameters, an Errorsargument can be used to examine the errors. If such an argument is not declared, a MethodArgumentNotValidExceptionwill be raised. The exception is handled in the DefaultHandlerExceptionResolver, which sends a 400error back to the client.

[Note] Note

Also see Section 22.16.1, “Enabling the MVC Java Config or the MVC XML Namespace”for information on configuring message converters and a validator through the MVC namespace or the MVC Java config.

Mapping the response body with the @ResponseBody annotation

The @ResponseBodyannotation is similar to @RequestBody. This annotation can be placed on a method and indicates that the return type should be written straight to the HTTP response body (and not placed in a Model, or interpreted as a view name). For example:

									
										@GetMapping("/something")
									
										@ResponseBody
									publicString helloWorld() {
									return
									"Hello World"; }

The above example will result in the text Hello Worldbeing written to the HTTP response stream.

As with @RequestBody, Spring converts the returned object to a response body by using an HttpMessageConverter. For more information on these converters, see the previous section and Message Converters.

Creating REST Controllers with the @RestController annotation

It’s a very common use case to have Controllers implement a REST API, thus serving only JSON, XML or custom MediaType content. For convenience, instead of annotating all your @RequestMappingmethods with @ResponseBody, you can annotate your controller Class with @RestController.

@RestControlleris a stereotype annotation that combines @ResponseBodyand @Controller. More than that, it gives more meaning to your Controller and also may carry additional semantics in future releases of the framework.

As with regular @Controllers, a @RestControllermay be assisted by @ControllerAdviceor @RestControllerAdvicebeans. See the the section called “Advising controllers with @ControllerAdvice and @RestControllerAdvice”section for more details.

Using HttpEntity

The HttpEntityis similar to @RequestBodyand @ResponseBody. Besides getting access to the request and response body, HttpEntity(and the response-specific subclass ResponseEntity) also allows access to the request and response headers, like so:

									
										@RequestMapping("/something")
									publicResponseEntity<String> handle(HttpEntity<
									byte[]> requestEntity)
									throwsUnsupportedEncodingException { String requestHeader = requestEntity.getHeaders().getFirst(
									"MyRequestHeader"));
									byte[] requestBody = requestEntity.getBody();
									// do something with request header and bodyHttpHeaders responseHeaders =
									newHttpHeaders(); responseHeaders.set(
									"MyResponseHeader",
									"MyValue");
									return
									newResponseEntity<String>(
									"Hello World", responseHeaders, HttpStatus.CREATED); }

The above example gets the value of the MyRequestHeaderrequest header, and reads the body as a byte array. It adds the MyResponseHeaderto the response, writes Hello Worldto the response stream, and sets the response status code to 201 (Created).

As with @RequestBodyand @ResponseBody, Spring uses HttpMessageConverterto convert from and to the request and response streams. For more information on these converters, see the previous section and Message Converters.

Using @ModelAttribute on a method

The @ModelAttributeannotation can be used on methods or on method arguments. This section explains its usage on methods while the next section explains its usage on method arguments.

An @ModelAttributeon a method indicates the purpose of that method is to add one or more model attributes. Such methods support the same argument types as @RequestMappingmethods but cannot be mapped directly to requests. Instead @ModelAttributemethods in a controller are invoked before @RequestMappingmethods, within the same controller. A couple of examples:

									// Add one attribute
									// The return value of the method is added to the model under the name "account"
									// You can customize the name via @ModelAttribute("myAccount")
									
										@ModelAttribute
									publicAccount addAccount(
									
										@RequestParamString number) {
									returnaccountManager.findAccount(number); }
									// Add multiple attributes
									
										@ModelAttribute
									public
									voidpopulateModel(
									
										@RequestParamString number, Model model) { model.addAttribute(accountManager.findAccount(number));
									// add more ...}

@ModelAttributemethods are used to populate the model with commonly needed attributes for example to fill a drop-down with states or with pet types, or to retrieve a command object like Account in order to use it to represent the data on an HTML form. The latter case is further discussed in the next section.

Note the two styles of @ModelAttributemethods. In the first, the method adds an attribute implicitly by returning it. In the second, the method accepts a Modeland adds any number of model attributes to it. You can choose between the two styles depending on your needs.

A controller can have any number of @ModelAttributemethods. All such methods are invoked before @RequestMappingmethods of the same controller.

@ModelAttributemethods can also be defined in an @ControllerAdvice-annotated class and such methods apply to many controllers. See the the section called “Advising controllers with @ControllerAdvice and @RestControllerAdvice”section for more details.

[Tip] Tip

What happens when a model attribute name is not explicitly specified? In such cases a default name is assigned to the model attribute based on its type. For example if the method returns an object of type Account, the default name used is "account". You can change that through the value of the @ModelAttributeannotation. If adding attributes directly to the Model, use the appropriate overloaded addAttribute(..)method - i.e., with or without an attribute name.

The @ModelAttributeannotation can be used on @RequestMappingmethods as well. In that case the return value of the @RequestMappingmethod is interpreted as a model attribute rather than as a view name. The view name is then derived based on view name conventions instead, much like for methods returning void — see Section 22.13.3, “The View - RequestToViewNameTranslator”.

Using @ModelAttribute on a method argument

As explained in the previous section @ModelAttributecan be used on methods or on method arguments. This section explains its usage on method arguments.

An @ModelAttributeon a method argument indicates the argument should be retrieved from the model. If not present in the model, the argument should be instantiated first and then added to the model. Once present in the model, the argument’s fields should be populated from all request parameters that have matching names. This is known as data binding in Spring MVC, a very useful mechanism that saves you from having to parse each form field individually.

									
										@PostMapping("/owners/{ownerId}/pets/{petId}/edit")
									publicString processSubmit(
									
										@ModelAttribute Pet pet) { }

Given the above example where can the Pet instance come from? There are several options:

An @ModelAttributemethod is a common way to retrieve an attribute from the database, which may optionally be stored between requests through the use of @SessionAttributes. In some cases it may be convenient to retrieve the attribute by using an URI template variable and a type converter. Here is an example:

									
										@PutMapping("/accounts/{account}")
									publicString save(
									
										@ModelAttribute("account")Account account) {
									// ...}

In this example the name of the model attribute (i.e. "account") matches the name of a URI template variable. If you register Converter<String, Account>that can turn the Stringaccount value into an Accountinstance, then the above example will work without the need for an @ModelAttributemethod.

The next step is data binding. The WebDataBinderclass matches request parameter names — including query string parameters and form fields — to model attribute fields by name. Matching fields are populated after type conversion (from String to the target field type) has been applied where necessary. Data binding and validation are covered in Chapter 9, Validation, Data Binding, and Type Conversion . Customizing the data binding process for a controller level is covered in the section called “Customizing WebDataBinder initialization”.

As a result of data binding there may be errors such as missing required fields or type conversion errors. To check for such errors add a BindingResultargument immediately following the @ModelAttributeargument:

									
										@PostMapping("/owners/{ownerId}/pets/{petId}/edit")
									publicString processSubmit(
									
										@ModelAttribute("pet") Pet pet, BindingResult result) {
									if(result.hasErrors()) {
									return
									"petForm"; }
									// ...}

With a BindingResultyou can check if errors were found in which case it’s common to render the same form where the errors can be shown with the help of Spring’s <errors>form tag.

Note that in some cases it may be useful to gain access to an attribute in the model without data binding. For such cases you may inject the Modelinto the controller or alternatively use the bindingflag on the annotation:

									
										@ModelAttribute
									publicAccountForm setUpForm() {
									return
									newAccountForm(); }
									
										@ModelAttribute
									publicAccount findAccount(
									
										@PathVariableString accountId) {
									returnaccountRepository.findOne(accountId); }
									
										@PostMapping("update")
									publicString update(
									
										@ValidAccountUpdateForm form, BindingResult result,
									
										@ModelAttribute(binding=false)Account account) {
									// ...}

In addition to data binding you can also invoke validation using your own custom validator passing the same BindingResultthat was used to record data binding errors. That allows for data binding and validation errors to be accumulated in one place and subsequently reported back to the user:

									
										@PostMapping("/owners/{ownerId}/pets/{petId}/edit")
									publicString processSubmit(
									
										@ModelAttribute("pet") Pet pet, BindingResult result) {
									newPetValidator().validate(pet, result);
									if(result.hasErrors()) {
									return
									"petForm"; }
									// ...}

Or you can have validation invoked automatically by adding the JSR-303 @Validannotation:

									
										@PostMapping("/owners/{ownerId}/pets/{petId}/edit")
									publicString processSubmit(
									
										@Valid @ModelAttribute("pet") Pet pet, BindingResult result) {
									if(result.hasErrors()) {
									return
									"petForm"; }
									// ...}

See Section 9.8, “Spring Validation”and Chapter 9, Validation, Data Binding, and Type Conversion for details on how to configure and use validation.

Using @SessionAttributes to store model attributes in the HTTP session between requests

The type-level @SessionAttributesannotation declares session attributes used by a specific handler. This will typically list the names of model attributes or types of model attributes which should be transparently stored in the session or some conversational storage, serving as form-backing beans between subsequent requests.

The following code snippet shows the usage of this annotation, specifying the model attribute name:

									
										@Controller
									
										@RequestMapping("/editPet.do")
									
										@SessionAttributes("pet")
									public
									classEditPetForm {
									// ...}

Using @SessionAttribute to access pre-existing global session attributes

If you need access to pre-existing session attributes that are managed globally, i.e. outside the controller (e.g. by a filter), and may or may not be present use the @SessionAttributeannotation on a method parameter:

									
										@RequestMapping("/")
									publicString handle(
									
										@SessionAttributeUser user) {
									// ...}

For use cases that require adding or removing session attributes consider injecting org.springframework.web.context.request.WebRequestor javax.servlet.http.HttpSessioninto the controller method.

For temporary storage of model attributes in the session as part of a controller workflow consider using SessionAttributesas described in the section called “Using @SessionAttributes to store model attributes in the HTTP session between requests”.

Using @RequestAttribute to access request attributes

Similar to @SessionAttributethe @RequestAttributeannotation can be used to access pre-existing request attributes created by a filter or interceptor:

									
										@RequestMapping("/")
									publicString handle(
									
										@RequestAttributeClient client) {
									// ...}

Working with "application/x-www-form-urlencoded" data

The previous sections covered use of @ModelAttributeto support form submission requests from browser clients. The same annotation is recommended for use with requests from non-browser clients as well. However there is one notable difference when it comes to working with HTTP PUT requests. Browsers can submit form data via HTTP GET or HTTP POST. Non-browser clients can also submit forms via HTTP PUT. This presents a challenge because the Servlet specification requires the ServletRequest.getParameter*()family of methods to support form field access only for HTTP POST, not for HTTP PUT.

To support HTTP PUT and PATCH requests, the spring-webmodule provides the filter HttpPutFormContentFilter, which can be configured in web.xml:

									<filter>
									<filter-name>httpPutFormFilter
									</filter-name>
									<filter-class>org.springframework.web.filter.HttpPutFormContentFilter
									</filter-class>
									</filter>
									<filter-mapping>
									<filter-name>httpPutFormFilter
									</filter-name>
									<servlet-name>dispatcherServlet
									</servlet-name>
									</filter-mapping>
									<servlet>
									<servlet-name>dispatcherServlet
									</servlet-name>
									<servlet-class>org.springframework.web.servlet.DispatcherServlet
									</servlet-class>
									</servlet>

The above filter intercepts HTTP PUT and PATCH requests with content type application/x-www-form-urlencoded, reads the form data from the body of the request, and wraps the ServletRequestin order to make the form data available through the ServletRequest.getParameter*()family of methods.

[Note] Note

As HttpPutFormContentFilterconsumes the body of the request, it should not be configured for PUT or PATCH URLs that rely on other converters for application/x-www-form-urlencoded. This includes @RequestBody MultiValueMap<String, String>and HttpEntity<MultiValueMap<String, String>>.

Mapping cookie values with the @CookieValue annotation

The @CookieValueannotation allows a method parameter to be bound to the value of an HTTP cookie.

Let us consider that the following cookie has been received with an http request:

JSESSIONID=415A4AC178C59DACE0B2C9CA727CDD84

The following code sample demonstrates how to get the value of the JSESSIONIDcookie:

									
										@RequestMapping("/displayHeaderInfo.do")
									public
									voiddisplayHeaderInfo(
									
										@CookieValue("JSESSIONID")String cookie) {
									//...}

Type conversion is applied automatically if the target method parameter type is not String. See the section called “Method Parameters And Type Conversion”.

This annotation is supported for annotated handler methods in Servlet and Portlet environments.

Mapping request header attributes with the @RequestHeader annotation

The @RequestHeaderannotation allows a method parameter to be bound to a request header.

Here is a sample request header:

Host localhost:8080 Accept text/html,application/xhtml+xml,application/xml;q=0.9 Accept-Language fr,en-gb;q=0.7,en;q=0.3 Accept-Encoding gzip,deflate Accept-Charset ISO-8859-1,utf-8;q=0.7,*;q=0.7 Keep-Alive 300

The following code sample demonstrates how to get the value of the Accept-Encodingand Keep-Aliveheaders:

									
										@RequestMapping("/displayHeaderInfo.do")
									public
									voiddisplayHeaderInfo(
									
										@RequestHeader("Accept-Encoding")String encoding,
									
										@RequestHeader("Keep-Alive")
									longkeepAlive) {
									//...}

Type conversion is applied automatically if the method parameter is not String. See the section called “Method Parameters And Type Conversion”.

When an @RequestHeaderannotation is used on a Map<String, String>, MultiValueMap<String, String>, or HttpHeadersargument, the map is populated with all header values.

[Tip] Tip

Built-in support is available for converting a comma-separated string into an array/collection of strings or other types known to the type conversion system. For example a method parameter annotated with @RequestHeader("Accept")may be of type Stringbut also String[]or List<String>.

This annotation is supported for annotated handler methods in Servlet and Portlet environments.

Method Parameters And Type Conversion

String-based values extracted from the request including request parameters, path variables, request headers, and cookie values may need to be converted to the target type of the method parameter or field (e.g., binding a request parameter to a field in an @ModelAttributeparameter) they’re bound to. If the target type is not String, Spring automatically converts to the appropriate type. All simple types such as int, long, Date, etc. are supported. You can further customize the conversion process through a WebDataBinder(see the section called “Customizing WebDataBinder initialization”) or by registering Formatterswith the FormattingConversionService(see Section 9.6, “Spring Field Formatting”).

Customizing WebDataBinder initialization

To customize request parameter binding with PropertyEditors through Spring’s WebDataBinder, you can use @InitBinder-annotated methods within your controller, @InitBindermethods within an @ControllerAdviceclass, or provide a custom WebBindingInitializer. See the the section called “Advising controllers with @ControllerAdvice and @RestControllerAdvice”section for more details.

Customizing data binding with @InitBinder

Annotating controller methods with @InitBinderallows you to configure web data binding directly within your controller class. @InitBinderidentifies methods that initialize the WebDataBinderthat will be used to populate command and form object arguments of annotated handler methods.

Such init-binder methods support all arguments that @RequestMappingmethods support, except for command/form objects and corresponding validation result objects. Init-binder methods must not have a return value. Thus, they are usually declared as void. Typical arguments include WebDataBinderin combination with WebRequestor java.util.Locale, allowing code to register context-specific editors.

The following example demonstrates the use of @InitBinderto configure a CustomDateEditorfor all java.util.Dateform properties.

										
											@Controller
										public
										classMyFormController {
										
											@InitBinder
										protected
										voidinitBinder(WebDataBinder binder) { SimpleDateFormat dateFormat =
										newSimpleDateFormat(
										"yyyy-MM-dd"); dateFormat.setLenient(false); binder.registerCustomEditor(Date.
										class,
										newCustomDateEditor(dateFormat, false)); }
										// ...}

Alternatively, as of Spring 4.2, consider using addCustomFormatterto specify Formatterimplementations instead of PropertyEditorinstances. This is particularly useful if you happen to have a Formatter-based setup in a shared FormattingConversionServiceas well, with the same approach to be reused for controller-specific tweaking of the binding rules.

										
											@Controller
										public
										classMyFormController {
										
											@InitBinder
										protected
										voidinitBinder(WebDataBinder binder) { binder.addCustomFormatter(
										newDateFormatter(
										"yyyy-MM-dd")); }
										// ...}
Configuring a custom WebBindingInitializer

To externalize data binding initialization, you can provide a custom implementation of the WebBindingInitializerinterface, which you then enable by supplying a custom bean configuration for an AnnotationMethodHandlerAdapter, thus overriding the default configuration.

The following example from the PetClinic application shows a configuration using a custom implementation of the WebBindingInitializerinterface, org.springframework.samples.petclinic.web.ClinicBindingInitializer, which configures PropertyEditors required by several of the PetClinic controllers.

										<bean
										class=
										"org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter"
										>
										<property
										name=
										"cacheSeconds"
										value=
										"0"
										/>
										<property
										name=
										"webBindingInitializer"
										>
										<bean
										class=
										"org.springframework.samples.petclinic.web.ClinicBindingInitializer"
										/>
										</property>
										</bean>

@InitBindermethods can also be defined in an @ControllerAdvice-annotated class in which case they apply to matching controllers. This provides an alternative to using a WebBindingInitializer. See the the section called “Advising controllers with @ControllerAdvice and @RestControllerAdvice”section for more details.

Advising controllers with @ControllerAdvice and @RestControllerAdvice

The @ControllerAdviceannotation is a component annotation allowing implementation classes to be auto-detected through classpath scanning. It is automatically enabled when using the MVC namespace or the MVC Java config.

Classes annotated with @ControllerAdvicecan contain @ExceptionHandler, @InitBinder, and @ModelAttributeannotated methods, and these methods will apply to @RequestMappingmethods across all controller hierarchies as opposed to the controller hierarchy within which they are declared.

@RestControllerAdviceis an alternative where @ExceptionHandlermethods assume @ResponseBodysemantics by default.

Both @ControllerAdviceand @RestControllerAdvicecan target a subset of controllers:

									// Target all Controllers annotated with @RestController
									
										@ControllerAdvice(annotations = RestController.class)
									public
									classAnnotationAdvice {}
									// Target all Controllers within specific packages
									
										@ControllerAdvice("org.example.controllers")
									public
									classBasePackageAdvice {}
									// Target all Controllers assignable to specific classes
									
										@ControllerAdvice(assignableTypes = {ControllerInterface.class, AbstractController.class})
									public
									classAssignableTypesAdvice {}

Check out the @ControllerAdvicedocumentationfor more details.

Jackson Serialization View Support

It can sometimes be useful to filter contextually the object that will be serialized to the HTTP response body. In order to provide such capability, Spring MVC has built-in support for rendering with Jackson’s Serialization Views.

To use it with an @ResponseBodycontroller method or controller methods that return ResponseEntity, simply add the @JsonViewannotation with a class argument specifying the view class or interface to be used:

									
										@RestController
									public
									classUserController {
									
										@GetMapping("/user")
									
										@JsonView(User.WithoutPasswordView.class)
									publicUser getUser() {
									return
									newUser(
									"eric",
									"7!jd#h23"); } }
									public
									classUser {
									public
									interfaceWithoutPasswordView {};
									public
									interfaceWithPasswordView
									extendsWithoutPasswordView {};
									privateString username;
									privateString password;
									publicUser() { }
									publicUser(String username, String password) {
									this.username = username;
									this.password = password; }
									
										@JsonView(WithoutPasswordView.class)
									publicString getUsername() {
									return
									this.username; }
									
										@JsonView(WithPasswordView.class)
									publicString getPassword() {
									return
									this.password; } }
[Note] Note

Note that despite @JsonViewallowing for more than one class to be specified, the use on a controller method is only supported with exactly one class argument. Consider the use of a composite interface if you need to enable multiple views.

For controllers relying on view resolution, simply add the serialization view class to the model:

									
										@Controller
									public
									classUserController
									extendsAbstractController {
									
										@GetMapping("/user")
									publicString getUser(Model model) { model.addAttribute(
									"user",
									newUser(
									"eric",
									"7!jd#h23")); model.addAttribute(JsonView.
									class.getName(), User.WithoutPasswordView.
									class);
									return
									"userView"; } }

Jackson JSONP Support

In order to enable JSONPsupport for @ResponseBodyand ResponseEntitymethods, declare an @ControllerAdvicebean that extends AbstractJsonpResponseBodyAdviceas shown below where the constructor argument indicates the JSONP query parameter name(s):

									
										@ControllerAdvice
									public
									classJsonpAdvice
									extendsAbstractJsonpResponseBodyAdvice {
									publicJsonpAdvice() {
									super(
									"callback"); } }

For controllers relying on view resolution, JSONP is automatically enabled when the request has a query parameter named jsonpor callback. Those names can be customized through jsonpParameterNamesproperty.

22.3.4 Asynchronous Request Processing

Spring MVC 3.2 introduced Servlet 3 based asynchronous request processing. Instead of returning a value, as usual, a controller method can now return a java.util.concurrent.Callableand produce the return value from a Spring MVC managed thread. Meanwhile the main Servlet container thread is exited and released and allowed to process other requests. Spring MVC invokes the Callablein a separate thread with the help of a TaskExecutorand when the Callablereturns, the request is dispatched back to the Servlet container to resume processing using the value returned by the Callable. Here is an example of such a controller method:

								
									@PostMapping
								publicCallable<String> processUpload(
								finalMultipartFile file) {
								return
								newCallable<String>() {
								publicString call()
								throwsException {
								// ...
								return
								"someView"; } }; }

Another option is for the controller method to return an instance of DeferredResult. In this case the return value will also be produced from any thread, i.e. one that is not managed by Spring MVC. For example the result may be produced in response to some external event such as a JMS message, a scheduled task, and so on. Here is an example of such a controller method:

								
									@RequestMapping("/quotes")
								
									@ResponseBody
								publicDeferredResult<String> quotes() { DeferredResult<String> deferredResult =
								newDeferredResult<String>();
								// Save the deferredResult somewhere..
								returndeferredResult; }
								// In some other thread...deferredResult.setResult(data);

This may be difficult to understand without any knowledge of the Servlet 3.0 asynchronous request processing features. It would certainly help to read up on that. Here are a few basic facts about the underlying mechanism:

  • A ServletRequestcan be put in asynchronous mode by calling request.startAsync(). The main effect of doing so is that the Servlet, as well as any Filters, can exit but the response will remain open to allow processing to complete later.
  • The call to request.startAsync()returns AsyncContextwhich can be used for further control over async processing. For example it provides the method dispatch, that is similar to a forward from the Servlet API except it allows an application to resume request processing on a Servlet container thread.
  • The ServletRequestprovides access to the current DispatcherTypethat can be used to distinguish between processing the initial request, an async dispatch, a forward, and other dispatcher types.

With the above in mind, the following is the sequence of events for async request processing with a Callable:

  • Controller returns a Callable.
  • Spring MVC starts asynchronous processing and submits the Callableto a TaskExecutorfor processing in a separate thread.
  • The DispatcherServletand all Filter’s exit the Servlet container thread but the response remains open.
  • The Callableproduces a result and Spring MVC dispatches the request back to the Servlet container to resume processing.
  • The DispatcherServletis invoked again and processing resumes with the asynchronously produced result from the Callable.

The sequence for DeferredResultis very similar except it’s up to the application to produce the asynchronous result from any thread:

  • Controller returns a DeferredResultand saves it in some in-memory queue or list where it can be accessed.
  • Spring MVC starts async processing.
  • The DispatcherServletand all configured Filter’s exit the request processing thread but the response remains open.
  • The application sets the DeferredResultfrom some thread and Spring MVC dispatches the request back to the Servlet container.
  • The DispatcherServletis invoked again and processing resumes with the asynchronously produced result.

For further background on the motivation for async request processing and when or why to use it please read this blog post series.

Exception Handling for Async Requests

What happens if a Callablereturned from a controller method raises an Exception while being executed? The short answer is the same as what happens when a controller method raises an exception. It goes through the regular exception handling mechanism. The longer explanation is that when a Callableraises an Exception Spring MVC dispatches to the Servlet container with the Exceptionas the result and that leads to resume request processing with the Exceptioninstead of a controller method return value. When using a DeferredResultyou have a choice whether to call setResultor setErrorResultwith an Exceptioninstance.

Intercepting Async Requests

A HandlerInterceptorcan also implement AsyncHandlerInterceptorin order to implement the afterConcurrentHandlingStartedcallback, which is called instead of postHandleand afterCompletionwhen asynchronous processing starts.

A HandlerInterceptorcan also register a CallableProcessingInterceptoror a DeferredResultProcessingInterceptorin order to integrate more deeply with the lifecycle of an asynchronous request and for example handle a timeout event. See the Javadoc of AsyncHandlerInterceptorfor more details.

The DeferredResulttype also provides methods such as onTimeout(Runnable)and onCompletion(Runnable). See the Javadoc of DeferredResultfor more details.

When using a Callableyou can wrap it with an instance of WebAsyncTaskwhich also provides registration methods for timeout and completion.

HTTP Streaming

A controller method can use DeferredResultand Callableto produce its return value asynchronously and that can be used to implement techniques such as long pollingwhere the server can push an event to the client as soon as possible.

What if you wanted to push multiple events on a single HTTP response? This is a technique related to "Long Polling" that is known as "HTTP Streaming". Spring MVC makes this possible through the ResponseBodyEmitterreturn value type which can be used to send multiple Objects, instead of one as is normally the case with @ResponseBody, where each Object sent is written to the response with an HttpMessageConverter.

Here is an example of that:

									
										@RequestMapping("/events")
									publicResponseBodyEmitter handle() { ResponseBodyEmitter emitter =
									newResponseBodyEmitter();
									// Save the emitter somewhere..
									returnemitter; }
									// In some other threademitter.send(
									"Hello once");
									// and again later onemitter.send(
									"Hello again");
									// and done at some pointemitter.complete();

Note that ResponseBodyEmittercan also be used as the body in a ResponseEntityin order to customize the status and headers of the response.

HTTP Streaming With Server-Sent Events

SseEmitteris a sub-class of ResponseBodyEmitterproviding support for Server-Sent Events. Server-sent events is a just another variation on the same "HTTP Streaming" technique except events pushed from the server are formatted according to the W3C Server-Sent Events specification.

Server-Sent Events can be used for their intended purpose, that is to push events from the server to clients. It is quite easy to do in Spring MVC and requires simply returning a value of type SseEmitter.

Note however that Internet Explorer does not support Server-Sent Events and that for more advanced web application messaging scenarios such as online games, collaboration, financial applicatinos, and others it’s better to consider Spring’s WebSocket support that includes SockJS-style WebSocket emulation falling back to a very wide range of browsers (including Internet Explorer) and also higher-level messaging patterns for interacting with clients through a publish-subscribe model within a more messaging-centric architecture. For further background on this see the following blog post.

HTTP Streaming Directly To The OutputStream

ResponseBodyEmitterallows sending events by writing Objects to the response through an HttpMessageConverter. This is probably the most common case, for example when writing JSON data. However sometimes it is useful to bypass message conversion and write directly to the response OutputStreamfor example for a file download. This can be done with the help of the StreamingResponseBodyreturn value type.

Here is an example of that:

									
										@RequestMapping("/download")
									publicStreamingResponseBody handle() {
									return
									newStreamingResponseBody() {
									
										@Override
									public
									voidwriteTo(OutputStream outputStream)
									throwsIOException {
									// write...} }; }

Note that StreamingResponseBodycan also be used as the body in a ResponseEntityin order to customize the status and headers of the response.

Configuring Asynchronous Request Processing

Servlet Container Configuration

For applications configured with a web.xmlbe sure to update to version 3.0:

										<web-app
										xmlns=
										"http://java.sun.com/xml/ns/javaee"
										xmlns:xsi=
										"http://www.w3.org/2001/XMLSchema-instance"
										http://java.sun.com/xml/ns/javaee
										http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"
										version=
										"3.0"
										>...
										</web-app>

Asynchronous support must be enabled on the DispatcherServletthrough the <async-supported>true</async-supported>sub-element in web.xml. Additionally any Filterthat participates in asyncrequest processing must be configured to support the ASYNC dispatcher type. It should be safe to enable the ASYNC dispatcher type for all filters provided with the Spring Framework since they usually extend OncePerRequestFilterand that has runtime checks for whether the filter needs to be involved in async dispatches or not.

Below is some example web.xml configuration:

										<web-app
										xmlns=
										"http://java.sun.com/xml/ns/javaee"
										xmlns:xsi=
										"http://www.w3.org/2001/XMLSchema-instance"
										xsi:schemaLocation=
										" http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"
										version=
										"3.0"
										>
										<filter>
										<filter-name>Spring OpenEntityManagerInViewFilter
										</filter-name>
										<filter-class>org.springframework.~.OpenEntityManagerInViewFilter
										</filter-class>
										<async-supported>true
										</async-supported>
										</filter>
										<filter-mapping>
										<filter-name>Spring OpenEntityManagerInViewFilter
										</filter-name>
										<url-pattern>/*
										</url-pattern>
										<dispatcher>REQUEST
										</dispatcher>
										<dispatcher>ASYNC
										</dispatcher>
										</filter-mapping>
										</web-app>

If using Servlet 3, Java based configuration for example via WebApplicationInitializer, you’ll also need to set the "asyncSupported" flag as well as the ASYNC dispatcher type just like with web.xml. To simplify all this configuration, consider extending AbstractDispatcherServletInitializer, or better AbstractAnnotationConfigDispatcherServletInitializerwhich automatically set those options and make it very easy to register Filterinstances.

Spring MVC Configuration

The MVC Java config and the MVC namespace provide options for configuring asynchronous request processing. WebMvcConfigurerhas the method configureAsyncSupportwhile <mvc:annotation-driven>has an <async-support>sub-element.

Those allow you to configure the default timeout value to use for async requests, which if not set depends on the underlying Servlet container (e.g. 10 seconds on Tomcat). You can also configure an AsyncTaskExecutorto use for executing Callableinstances returned from controller methods. It is highly recommended to configure this property since by default Spring MVC uses SimpleAsyncTaskExecutor. The MVC Java config and the MVC namespace also allow you to register CallableProcessingInterceptorand DeferredResultProcessingInterceptorinstances.

If you need to override the default timeout value for a specific DeferredResult, you can do so by using the appropriate class constructor. Similarly, for a Callable, you can wrap it in a WebAsyncTaskand use the appropriate class constructor to customize the timeout value. The class constructor of WebAsyncTaskalso allows providing an AsyncTaskExecutor.

22.3.5 Testing Controllers

The spring-testmodule offers first class support for testing annotated controllers. See Section 15.6, “Spring MVC Test Framework”.

22.4 Handler mappings

In previous versions of Spring, users were required to define one or more HandlerMappingbeans in the web application context to map incoming web requests to appropriate handlers. With the introduction of annotated controllers, you generally don’t need to do that because the RequestMappingHandlerMappingautomatically looks for @RequestMappingannotations on all @Controllerbeans. However, do keep in mind that all HandlerMappingclasses extending from AbstractHandlerMappinghave the following properties that you can use to customize their behavior:

  • interceptorsList of interceptors to use. HandlerInterceptors are discussed in Section 22.4.1, “Intercepting requests with a HandlerInterceptor”.
  • defaultHandlerDefault handler to use, when this handler mapping does not result in a matching handler.
  • orderBased on the value of the order property (see the org.springframework.core.Orderedinterface), Spring sorts all handler mappings available in the context and applies the first matching handler.
  • alwaysUseFullPathIf true, Spring uses the full path within the current Servlet context to find an appropriate handler. If false(the default), the path within the current Servlet mapping is used. For example, if a Servlet is mapped using /testing/*and the alwaysUseFullPathproperty is set to true, /testing/viewPage.htmlis used, whereas if the property is set to false, /viewPage.htmlis used.
  • urlDecodeDefaults to true, as of Spring 2.5. If you prefer to compare encoded paths, set this flag to false. However, the HttpServletRequestalways exposes the Servlet path in decoded form. Be aware that the Servlet path will not match when compared with encoded paths.

The following example shows how to configure an interceptor:

							<beans>
							<bean
							class=
							"org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping"
							>
							<property
							name=
							"interceptors"
							>
							<bean
							class=
							"example.MyInterceptor"
							/>
							</property>
							</bean>
							<beans>

22.4.1 Intercepting requests with a HandlerInterceptor

Spring’s handler mapping mechanism includes handler interceptors, which are useful when you want to apply specific functionality to certain requests, for example, checking for a principal.

Interceptors located in the handler mapping must implement HandlerInterceptorfrom the org.springframework.web.servletpackage. This interface defines three methods: preHandle(..)is called beforethe actual handler is executed; postHandle(..)is called afterthe handler is executed; and afterCompletion(..)is called after the complete request has finished. These three methods should provide enough flexibility to do all kinds of preprocessing and postprocessing.

The preHandle(..)method returns a boolean value. You can use this method to break or continue the processing of the execution chain. When this method returns true, the handler execution chain will continue; when it returns false, the DispatcherServletassumes the interceptor itself has taken care of requests (and, for example, rendered an appropriate view) and does not continue executing the other interceptors and the actual handler in the execution chain.

Interceptors can be configured using the interceptorsproperty, which is present on all HandlerMappingclasses extending from AbstractHandlerMapping. This is shown in the example below:

								<beans>
								<bean
								id=
								"handlerMapping"
								class=
								"org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping"
								>
								<property
								name=
								"interceptors"
								>
								<list>
								<ref
								bean=
								"officeHoursInterceptor"
								/>
								</list>
								</property>
								</bean>
								<bean
								id=
								"officeHoursInterceptor"
								class=
								"samples.TimeBasedAccessInterceptor"
								>
								<property
								name=
								"openingTime"
								value=
								"9"
								/>
								<property
								name=
								"closingTime"
								value=
								"18"
								/>
								</bean>
								</beans>
								packagesamples;
								public
								classTimeBasedAccessInterceptor
								extendsHandlerInterceptorAdapter {
								private
								intopeningTime;
								private
								intclosingTime;
								public
								voidsetOpeningTime(
								intopeningTime) {
								this.openingTime = openingTime; }
								public
								voidsetClosingTime(
								intclosingTime) {
								this.closingTime = closingTime; }
								public
								booleanpreHandle(HttpServletRequest request, HttpServletResponse response, Object handler)
								throwsException { Calendar cal = Calendar.getInstance();
								inthour = cal.get(HOUR_OF_DAY);
								if(openingTime <= hour && hour < closingTime) {
								returntrue; } response.sendRedirect(
								"http://host.com/outsideOfficeHours.html");
								returnfalse; } }

Any request handled by this mapping is intercepted by the TimeBasedAccessInterceptor. If the current time is outside office hours, the user is redirected to a static HTML file that says, for example, you can only access the website during office hours.

[Note] Note

When using the RequestMappingHandlerMappingthe actual handler is an instance of HandlerMethodwhich identifies the specific controller method that will be invoked.

As you can see, the Spring adapter class HandlerInterceptorAdaptermakes it easier to extend the HandlerInterceptorinterface.

[Tip] Tip

In the example above, the configured interceptor will apply to all requests handled with annotated controller methods. If you want to narrow down the URL paths to which an interceptor applies, you can use the MVC namespace or the MVC Java config, or declare bean instances of type MappedInterceptorto do that. See Section 22.16.1, “Enabling the MVC Java Config or the MVC XML Namespace”.

Note that the postHandlemethod of HandlerInterceptoris not always ideally suited for use with @ResponseBodyand ResponseEntitymethods. In such cases an HttpMessageConverterwrites to and commits the response before postHandleis called which makes it impossible to change the response, for example to add a header. Instead an application can implement ResponseBodyAdviceand either declare it as an @ControllerAdvicebean or configure it directly on RequestMappingHandlerAdapter.

22.5 Resolving views

All MVC frameworks for web applications provide a way to address views. Spring provides view resolvers, which enable you to render models in a browser without tying you to a specific view technology. Out of the box, Spring enables you to use JSPs, Velocity templates and XSLT views, for example. See Chapter 23, View technologies for a discussion of how to integrate and use a number of disparate view technologies.

The two interfaces that are important to the way Spring handles views are ViewResolverand View. The ViewResolverprovides a mapping between view names and actual views. The Viewinterface addresses the preparation of the request and hands the request over to one of the view technologies.

22.5.1 Resolving views with the ViewResolver interface

As discussed in Section 22.3, “Implementing Controllers”, all handler methods in the Spring Web MVC controllers must resolve to a logical view name, either explicitly (e.g., by returning a String, View, or ModelAndView) or implicitly (i.e., based on conventions). Views in Spring are addressed by a logical view name and are resolved by a view resolver. Spring comes with quite a few view resolvers. This table lists most of them; a couple of examples follow.

Table 22.3. View resolvers

ViewResolver Description

AbstractCachingViewResolver

Abstract view resolver that caches views. Often views need preparation before they can be used; extending this view resolver provides caching.

XmlViewResolver

Implementation of ViewResolverthat accepts a configuration file written in XML with the same DTD as Spring’s XML bean factories. The default configuration file is /WEB-INF/views.xml.

ResourceBundleViewResolver

Implementation of ViewResolverthat uses bean definitions in a ResourceBundle, specified by the bundle base name. Typically you define the bundle in a properties file, located in the classpath. The default file name is views.properties.

UrlBasedViewResolver

Simple implementation of the ViewResolverinterface that effects the direct resolution of logical view names to URLs, without an explicit mapping definition. This is appropriate if your logical names match the names of your view resources in a straightforward manner, without the need for arbitrary mappings.

InternalResourceViewResolver

Convenient subclass of UrlBasedViewResolverthat supports InternalResourceView(in effect, Servlets and JSPs) and subclasses such as JstlViewand TilesView. You can specify the view class for all views generated by this resolver by using setViewClass(..). See the UrlBasedViewResolverjavadocs for details.

VelocityViewResolver/ FreeMarkerViewResolver

Convenient subclass of UrlBasedViewResolverthat supports VelocityView(in effect, Velocity templates) or FreeMarkerView,respectively, and custom subclasses of them.

ContentNegotiatingViewResolver

Implementation of the ViewResolverinterface that resolves a view based on the request file name or Acceptheader. See Section 22.5.4, “ContentNegotiatingViewResolver”.

As an example, with JSP as a view technology, you can use the UrlBasedViewResolver. This view resolver translates a view name to a URL and hands the request over to the RequestDispatcher to render the view.

								<bean
								id=
								"viewResolver"
								class=
								"org.springframework.web.servlet.view.UrlBasedViewResolver"
								>
								<property
								name=
								"viewClass"
								value=
								"org.springframework.web.servlet.view.JstlView"
								/>
								<property
								name=
								"prefix"
								value=
								"/WEB-INF/jsp/"
								/>
								<property
								name=
								"suffix"
								value=
								".jsp"
								/>
								</bean>

When returning testas a logical view name, this view resolver forwards the request to the RequestDispatcherthat will send the request to /WEB-INF/jsp/test.jsp.

When you combine different view technologies in a web application, you can use the ResourceBundleViewResolver:

								<bean
								id=
								"viewResolver"
								class=
								"org.springframework.web.servlet.view.ResourceBundleViewResolver"
								>
								<property
								name=
								"basename"
								value=
								"views"
								/>
								<property
								name=
								"defaultParentView"
								value=
								"parentView"
								/>
								</bean>

The ResourceBundleViewResolverinspects the ResourceBundleidentified by the basename, and for each view it is supposed to resolve, it uses the value of the property [viewname].(class)as the view class and the value of the property [viewname].urlas the view url. Examples can be found in the next chapter which covers view technologies. As you can see, you can identify a parent view, from which all views in the properties file "extend". This way you can specify a default view class, for example.

[Note] Note

Subclasses of AbstractCachingViewResolvercache view instances that they resolve. Caching improves performance of certain view technologies. It’s possible to turn off the cache by setting the cacheproperty to false. Furthermore, if you must refresh a certain view at runtime (for example when a Velocity template is modified), you can use the removeFromCache(String viewName, Locale loc)method.

22.5.2 Chaining ViewResolvers

Spring supports multiple view resolvers. Thus you can chain resolvers and, for example, override specific views in certain circumstances. You chain view resolvers by adding more than one resolver to your application context and, if necessary, by setting the orderproperty to specify ordering. Remember, the higher the order property, the later the view resolver is positioned in the chain.

In the following example, the chain of view resolvers consists of two resolvers, an InternalResourceViewResolver, which is always automatically positioned as the last resolver in the chain, and an XmlViewResolverfor specifying Excel views. Excel views are not supported by the InternalResourceViewResolver.

								<bean
								id=
								"jspViewResolver"
								class=
								"org.springframework.web.servlet.view.InternalResourceViewResolver"
								>
								<property
								name=
								"viewClass"
								value=
								"org.springframework.web.servlet.view.JstlView"
								/>
								<property
								name=
								"prefix"
								value=
								"/WEB-INF/jsp/"
								/>
								<property
								name=
								"suffix"
								value=
								".jsp"
								/>
								</bean>
								<bean
								id=
								"excelViewResolver"
								class=
								"org.springframework.web.servlet.view.XmlViewResolver"
								>
								<property
								name=
								"order"
								value=
								"1"
								/>
								<property
								name=
								"location"
								value=
								"/WEB-INF/views.xml"
								/>
								</bean>
								<!-- in views.xml -->
								<beans>
								<bean
								name=
								"report"
								class=
								"org.springframework.example.ReportExcelView"
								/>
								</beans>

If a specific view resolver does not result in a view, Spring examines the context for other view resolvers. If additional view resolvers exist, Spring continues to inspect them until a view is resolved. If no view resolver returns a view, Spring throws a ServletException.

The contract of a view resolver specifies that a view resolver canreturn null to indicate the view could not be found. Not all view resolvers do this, however, because in some cases, the resolver simply cannot detect whether or not the view exists. For example, the InternalResourceViewResolveruses the RequestDispatcherinternally, and dispatching is the only way to figure out if a JSP exists, but this action can only execute once. The same holds for the VelocityViewResolverand some others. Check the javadocs of the specific view resolver to see whether it reports non-existing views. Thus, putting an InternalResourceViewResolverin the chain in a place other than the last results in the chain not being fully inspected, because the InternalResourceViewResolverwill alwaysreturn a view!

22.5.3 Redirecting to Views

As mentioned previously, a controller typically returns a logical view name, which a view resolver resolves to a particular view technology. For view technologies such as JSPs that are processed through the Servlet or JSP engine, this resolution is usually handled through the combination of InternalResourceViewResolverand InternalResourceView, which issues an internal forward or include via the Servlet API’s RequestDispatcher.forward(..)method or RequestDispatcher.include()method. For other view technologies, such as Velocity, XSLT, and so on, the view itself writes the content directly to the response stream.

It is sometimes desirable to issue an HTTP redirect back to the client, before the view is rendered. This is desirable, for example, when one controller has been called with POSTdata, and the response is actually a delegation to another controller (for example on a successful form submission). In this case, a normal internal forward will mean that the other controller will also see the same POSTdata, which is potentially problematic if it can confuse it with other expected data. Another reason to perform a redirect before displaying the result is to eliminate the possibility of the user submitting the form data multiple times. In this scenario, the browser will first send an initial POST; it will then receive a response to redirect to a different URL; and finally the browser will perform a subsequent GETfor the URL named in the redirect response. Thus, from the perspective of the browser, the current page does not reflect the result of a POSTbut rather of a GET. The end effect is that there is no way the user can accidentally re- POSTthe same data by performing a refresh. The refresh forces a GETof the result page, not a resend of the initial POSTdata.

RedirectView

One way to force a redirect as the result of a controller response is for the controller to create and return an instance of Spring’s RedirectView. In this case, DispatcherServletdoes not use the normal view resolution mechanism. Rather because it has been given the (redirect) view already, the DispatcherServletsimply instructs the view to do its work. The RedirectViewin turn calls HttpServletResponse.sendRedirect()to send an HTTP redirect to the client browser.

If you use RedirectViewand the view is created by the controller itself, it is recommended that you configure the redirect URL to be injected into the controller so that it is not baked into the controller but configured in the context along with the view names. The the section called “The redirect: prefix”facilitates this decoupling.

Passing Data To the Redirect Target

By default all model attributes are considered to be exposed as URI template variables in the redirect URL. Of the remaining attributes those that are primitive types or collections/arrays of primitive types are automatically appended as query parameters.

Appending primitive type attributes as query parameters may be the desired result if a model instance was prepared specifically for the redirect. However, in annotated controllers the model may contain additional attributes added for rendering purposes (e.g. drop-down field values). To avoid the possibility of having such attributes appear in the URL, an @RequestMappingmethod can declare an argument of type RedirectAttributesand use it to specify the exact attributes to make available to RedirectView. If the method does redirect, the content of RedirectAttributesis used. Otherwise the content of the model is used.

The RequestMappingHandlerAdapterprovides a flag called "ignoreDefaultModelOnRedirect"that can be used to indicate the content of the default Modelshould never be used if a controller method redirects. Instead the controller method should declare an attribute of type RedirectAttributesor if it doesn’t do so no attributes should be passed on to RedirectView. Both the MVC namespace and the MVC Java config keep this flag set to falsein order to maintain backwards compatibility. However, for new applications we recommend setting it to true

Note that URI template variables from the present request are automatically made available when expanding a redirect URL and do not need to be added explicitly neither through Modelnor RedirectAttributes. For example:

										
											@PostMapping("/files/{path}")
										publicString upload(...) {
										// ...
										return
										"redirect:files/{path}"; }

Another way of passing data to the redirect target is via Flash Attributes. Unlike other redirect attributes, flash attributes are saved in the HTTP session (and hence do not appear in the URL). See Section 22.6, “Using flash attributes”for more information.

The redirect: prefix

While the use of RedirectViewworks fine, if the controller itself creates the RedirectView, there is no avoiding the fact that the controller is aware that a redirection is happening. This is really suboptimal and couples things too tightly. The controller should not really care about how the response gets handled. In general it should operate only in terms of view names that have been injected into it.

The special redirect:prefix allows you to accomplish this. If a view name is returned that has the prefix redirect:, the UrlBasedViewResolver(and all subclasses) will recognize this as a special indication that a redirect is needed. The rest of the view name will be treated as the redirect URL.

The net effect is the same as if the controller had returned a RedirectView, but now the controller itself can simply operate in terms of logical view names. A logical view name such as redirect:/myapp/some/resourcewill redirect relative to the current Servlet context, while a name such as redirect:http://myhost.com/some/arbitrary/pathwill redirect to an absolute URL.

Note that the controller handler is annotated with the @ResponseStatus, the annotation value takes precedence over the response status set by RedirectView.

The forward: prefix

It is also possible to use a special forward:prefix for view names that are ultimately resolved by UrlBasedViewResolverand subclasses. This creates an InternalResourceView(which ultimately does a RequestDispatcher.forward()) around the rest of the view name, which is considered a URL. Therefore, this prefix is not useful with InternalResourceViewResolverand InternalResourceView(for JSPs for example). But the prefix can be helpful when you are primarily using another view technology, but still want to force a forward of a resource to be handled by the Servlet/JSP engine. (Note that you may also chain multiple view resolvers, instead.)

As with the redirect:prefix, if the view name with the forward:prefix is injected into the controller, the controller does not detect that anything special is happening in terms of handling the response.

22.5.4 ContentNegotiatingViewResolver

The ContentNegotiatingViewResolverdoes not resolve views itself but rather delegates to other view resolvers, selecting the view that resembles the representation requested by the client. Two strategies exist for a client to request a representation from the server:

[Note] Note

One issue with the Acceptheader is that it is impossible to set it in a web browser within HTML. For example, in Firefox, it is fixed to:

Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8

For this reason it is common to see the use of a distinct URI for each representation when developing browser based web applications.

To support multiple representations of a resource, Spring provides the ContentNegotiatingViewResolverto resolve a view based on the file extension or Acceptheader of the HTTP request. ContentNegotiatingViewResolverdoes not perform the view resolution itself but instead delegates to a list of view resolvers that you specify through the bean property ViewResolvers.

The ContentNegotiatingViewResolverselects an appropriate Viewto handle the request by comparing the request media type(s) with the media type (also known as Content-Type) supported by the Viewassociated with each of its ViewResolvers. The first Viewin the list that has a compatible Content-Typereturns the representation to the client. If a compatible view cannot be supplied by the ViewResolverchain, then the list of views specified through the DefaultViewsproperty will be consulted. This latter option is appropriate for singleton Viewsthat can render an appropriate representation of the current resource regardless of the logical view name. The Acceptheader may include wild cards, for example text/*, in which case a Viewwhose Content-Type was text/xmlis a compatible match.

To support custom resolution of a view based on a file extension, use a ContentNegotiationManager: see Section 22.16.6, “Content Negotiation”.

Here is an example configuration of a ContentNegotiatingViewResolver:

								<bean
								class=
								"org.springframework.web.servlet.view.ContentNegotiatingViewResolver"
								>
								<property
								name=
								"viewResolvers"
								>
								<list>
								<bean
								class=
								"org.springframework.web.servlet.view.BeanNameViewResolver"
								/>
								<bean
								class=
								"org.springframework.web.servlet.view.InternalResourceViewResolver"
								>
								<property
								name=
								"prefix"
								value=
								"/WEB-INF/jsp/"
								/>
								<property
								name=
								"suffix"
								value=
								".jsp"
								/>
								</bean>
								</list>
								</property>
								<property
								name=
								"defaultViews"
								>
								<list>
								<bean
								class=
								"org.springframework.web.servlet.view.json.MappingJackson2JsonView"
								/>
								</list>
								</property>
								</bean>
								<bean
								id=
								"content"
								class=
								"com.foo.samples.rest.SampleContentAtomView"
								/>

The InternalResourceViewResolverhandles the translation of view names and JSP pages, while the BeanNameViewResolverreturns a view based on the name of a bean. (See " Resolving views with the ViewResolver interface" for more details on how Spring looks up and instantiates a view.) In this example, the contentbean is a class that inherits from AbstractAtomFeedView, which returns an Atom RSS feed. For more information on creating an Atom Feed representation, see the section Atom Views.

In the above configuration, if a request is made with an .htmlextension, the view resolver looks for a view that matches the text/htmlmedia type. The InternalResourceViewResolverprovides the matching view for text/html. If the request is made with the file extension .atom, the view resolver looks for a view that matches the application/atom+xmlmedia type. This view is provided by the BeanNameViewResolverthat maps to the SampleContentAtomViewif the view name returned is content. If the request is made with the file extension .json, the MappingJackson2JsonViewinstance from the DefaultViewslist will be selected regardless of the view name. Alternatively, client requests can be made without a file extension but with the Acceptheader set to the preferred media-type, and the same resolution of request to views would occur.

[Note] Note

If `ContentNegotiatingViewResolver’s list of ViewResolvers is not configured explicitly, it automatically uses any ViewResolvers defined in the application context.

The corresponding controller code that returns an Atom RSS feed for a URI of the form http://localhost/content.atomor http://localhost/contentwith an Acceptheader of application/atom+xml is shown below.

								
									@Controller
								public
								classContentController {
								privateList<SampleContent> contentList =
								newArrayList<SampleContent>();
								
									@GetMapping("/content")
								publicModelAndView getContent() { ModelAndView mav =
								newModelAndView(); mav.setViewName(
								"content"); mav.addObject(
								"sampleContentList", contentList);
								returnmav; } }

22.6 Using flash attributes

Flash attributes provide a way for one request to store attributes intended for use in another. This is most commonly needed when redirecting — for example, the Post/Redirect/Getpattern. Flash attributes are saved temporarily before the redirect (typically in the session) to be made available to the request after the redirect and removed immediately.

Spring MVC has two main abstractions in support of flash attributes. FlashMapis used to hold flash attributes while FlashMapManageris used to store, retrieve, and manage FlashMapinstances.

Flash attribute support is always "on" and does not need to enabled explicitly although if not used, it never causes HTTP session creation. On each request there is an "input" FlashMapwith attributes passed from a previous request (if any) and an "output" FlashMapwith attributes to save for a subsequent request. Both FlashMapinstances are accessible from anywhere in Spring MVC through static methods in RequestContextUtils.

Annotated controllers typically do not need to work with FlashMapdirectly. Instead an @RequestMappingmethod can accept an argument of type RedirectAttributesand use it to add flash attributes for a redirect scenario. Flash attributes added via RedirectAttributesare automatically propagated to the "output" FlashMap. Similarly, after the redirect, attributes from the "input" FlashMapare automatically added to the Modelof the controller serving the target URL.

Matching requests to flash attributes

The concept of flash attributes exists in many other Web frameworks and has proven to be exposed sometimes to concurrency issues. This is because by definition flash attributes are to be stored until the next request. However the very "next" request may not be the intended recipient but another asynchronous request (e.g. polling or resource requests) in which case the flash attributes are removed too early.

To reduce the possibility of such issues, RedirectViewautomatically "stamps" FlashMapinstances with the path and query parameters of the target redirect URL. In turn the default FlashMapManagermatches that information to incoming requests when looking up the "input" FlashMap.

This does not eliminate the possibility of a concurrency issue entirely but nevertheless reduces it greatly with information that is already available in the redirect URL. Therefore the use of flash attributes is recommended mainly for redirect scenarios .

22.7 Building URIs

Spring MVC provides a mechanism for building and encoding a URI using UriComponentsBuilderand UriComponents.

For example you can expand and encode a URI template string:

UriComponents uriComponents = UriComponentsBuilder.fromUriString(
							"http://example.com/hotels/{hotel}/bookings/{booking}").build(); URI uri = uriComponents.expand(
							"42",
							"21").encode().toUri();

Note that UriComponentsis immutable and the expand()and encode()operations return new instances if necessary.

You can also expand and encode using individual URI components:

UriComponents uriComponents = UriComponentsBuilder.newInstance() .scheme(
							"http").host(
							"example.com").path(
							"/hotels/{hotel}/bookings/{booking}").build() .expand(
							"42",
							"21") .encode();

In a Servlet environment the ServletUriComponentsBuildersub-class provides static factory methods to copy available URL information from a Servlet requests:

HttpServletRequest request = ...
							// Re-use host, scheme, port, path and query string
							// Replace the "accountId" query paramServletUriComponentsBuilder ucb = ServletUriComponentsBuilder.fromRequest(request) .replaceQueryParam(
							"accountId",
							"{id}").build() .expand(
							"123") .encode();

Alternatively, you may choose to copy a subset of the available information up to and including the context path:

							// Re-use host, port and context path
							// Append "/accounts" to the pathServletUriComponentsBuilder ucb = ServletUriComponentsBuilder.fromContextPath(request) .path(
							"/accounts").build()

Or in cases where the DispatcherServletis mapped by name (e.g. /main/*), you can also have the literal part of the servlet mapping included:

							// Re-use host, port, context path
							// Append the literal part of the servlet mapping to the path
							// Append "/accounts" to the pathServletUriComponentsBuilder ucb = ServletUriComponentsBuilder.fromServletMapping(request) .path(
							"/accounts").build()

22.7.1 Building URIs to Controllers and methods

Spring MVC also provides a mechanism for building links to controller methods. For example, given:

								
									@Controller
								
									@RequestMapping("/hotels/{hotel}")
								public
								classBookingController {
								
									@GetMapping("/bookings/{booking}")
								publicString getBooking(
								
									@PathVariableLong booking) {
								// ...} }

You can prepare a link by referring to the method by name:

UriComponents uriComponents = MvcUriComponentsBuilder .fromMethodName(BookingController.
								class,
								"getBooking",
								21).buildAndExpand(
								42); URI uri = uriComponents.encode().toUri();

In the above example we provided actual method argument values, in this case the long value 21, to be used as a path variable and inserted into the URL. Furthermore, we provided the value 42 in order to fill in any remaining URI variables such as the "hotel" variable inherited from the type-level request mapping. If the method had more arguments you can supply null for arguments not needed for the URL. In general only @PathVariableand @RequestParamarguments are relevant for constructing the URL.

There are additional ways to use MvcUriComponentsBuilder. For example you can use a technique akin to mock testing through proxies to avoid referring to the controller method by name (the example assumes static import of MvcUriComponentsBuilder.on):

UriComponents uriComponents = MvcUriComponentsBuilder .fromMethodCall(on(BookingController.
								class).getBooking(
								21)).buildAndExpand(
								42); URI uri = uriComponents.encode().toUri();

The above examples use static methods in MvcUriComponentsBuilder. Internally they rely on ServletUriComponentsBuilderto prepare a base URL from the scheme, host, port, context path and servlet path of the current request. This works well in most cases, however sometimes it may be insufficient. For example you may be outside the context of a request (e.g. a batch process that prepares links) or perhaps you need to insert a path prefix (e.g. a locale prefix that was removed from the request path and needs to be re-inserted into links).

For such cases you can use the static "fromXxx" overloaded methods that accept a UriComponentsBuilderto use base URL. Or you can create an instance of MvcUriComponentsBuilderwith a base URL and then use the instance-based "withXxx" methods. For example:

UriComponentsBuilder base = ServletUriComponentsBuilder.fromCurrentContextPath().path(
								"/en"); MvcUriComponentsBuilder builder = MvcUriComponentsBuilder.relativeTo(base); builder.withMethodCall(on(BookingController.
								class).getBooking(
								21)).buildAndExpand(
								42); URI uri = uriComponents.encode().toUri();

22.7.2 Building URIs to Controllers and methods from views

You can also build links to annotated controllers from views such as JSP, Thymeleaf, FreeMarker. This can be done using the fromMappingNamemethod in MvcUriComponentsBuilderwhich refers to mappings by name.

Every @RequestMappingis assigned a default name based on the capital letters of the class and the full method name. For example, the method getFooin class FooControlleris assigned the name "FC#getFoo". This strategy can be replaced or customized by creating an instance of HandlerMethodMappingNamingStrategyand plugging it into your RequestMappingHandlerMapping. The default strategy implementation also looks at the name attribute on @RequestMappingand uses that if present. That means if the default mapping name assigned conflicts with another (e.g. overloaded methods) you can assign a name explicitly on the @RequestMapping.

[Note] Note

The assigned request mapping names are logged at TRACE level on startup.

The Spring JSP tag library provides a function called mvcUrlthat can be used to prepare links to controller methods based on this mechanism.

For example given:

								
									@RequestMapping("/people/{id}/addresses")
								public
								classPersonAddressController {
								
									@RequestMapping("/{country}")
								publicHttpEntity getAddress(
								
									@PathVariableString country) { ... } }

You can prepare a link from a JSP as follows:

<%@ taglib uri="http://www.springframework.org/tags" prefix="s" %> ... <a href="${s:mvcUrl('PAC#getAddress').arg(0,'US').buildAndExpand('123')}">Get Address</a>

The above example relies on the mvcUrlJSP function declared in the Spring tag library (i.e. META-INF/spring.tld). For more advanced cases (e.g. a custom base URL as explained in the previous section), it is easy to define your own function, or use a custom tag file, in order to use a specific instance of MvcUriComponentsBuilderwith a custom base URL.

22.8 Using locales

Most parts of Spring’s architecture support internationalization, just as the Spring web MVC framework does. DispatcherServletenables you to automatically resolve messages using the client’s locale. This is done with LocaleResolverobjects.

When a request comes in, the DispatcherServletlooks for a locale resolver, and if it finds one it tries to use it to set the locale. Using the RequestContext.getLocale()method, you can always retrieve the locale that was resolved by the locale resolver.

In addition to automatic locale resolution, you can also attach an interceptor to the handler mapping (see Section 22.4.1, “Intercepting requests with a HandlerInterceptor”for more information on handler mapping interceptors) to change the locale under specific circumstances, for example, based on a parameter in the request.

Locale resolvers and interceptors are defined in the org.springframework.web.servlet.i18npackage and are configured in your application context in the normal way. Here is a selection of the locale resolvers included in Spring.

22.8.1 Obtaining Time Zone Information

In addition to obtaining the client’s locale, it is often useful to know their time zone. The LocaleContextResolverinterface offers an extension to LocaleResolverthat allows resolvers to provide a richer LocaleContext, which may include time zone information.

When available, the user’s TimeZonecan be obtained using the RequestContext.getTimeZone()method. Time zone information will automatically be used by Date/Time Converterand Formatterobjects registered with Spring’s ConversionService.

22.8.2 AcceptHeaderLocaleResolver

This locale resolver inspects the accept-languageheader in the request that was sent by the client (e.g., a web browser). Usually this header field contains the locale of the client’s operating system. Note that this resolver does not support time zone information.

22.8.3 CookieLocaleResolver

This locale resolver inspects a Cookiethat might exist on the client to see if a Localeor TimeZoneis specified. If so, it uses the specified details. Using the properties of this locale resolver, you can specify the name of the cookie as well as the maximum age. Find below an example of defining a CookieLocaleResolver.

								<bean
								id=
								"localeResolver"
								class=
								"org.springframework.web.servlet.i18n.CookieLocaleResolver"
								>
								<property
								name=
								"cookieName"
								value=
								"clientlanguage"
								/>
								<!-- in seconds. If set to -1, the cookie is not persisted (deleted when browser shuts down) -->
								<property
								name=
								"cookieMaxAge"
								value=
								"100000"
								/>
								</bean>

Table 22.4. CookieLocaleResolver properties

Property Default Description

cookieName

classname + LOCALE

The name of the cookie

cookieMaxAge

Integer.MAX_INT

The maximum time a cookie will stay persistent on the client. If -1 is specified, the cookie will not be persisted; it will only be available until the client shuts down their browser.

cookiePath

/

Limits the visibility of the cookie to a certain part of your site. When cookiePath is specified, the cookie will only be visible to that path and the paths below it.

22.8.4 SessionLocaleResolver

The SessionLocaleResolverallows you to retrieve Localeand TimeZonefrom the session that might be associated with the user’s request. In contrast to CookieLocaleResolver, this strategy stores locally chosen locale settings in the Servlet container’s HttpSession. As a consequence, those settings are just temporary for each session and therefore lost when each session terminates.

Note that there is no direct relationship with external session management mechanisms such as the Spring Session project. This SessionLocaleResolverwill simply evaluate and modify corresponding HttpSessionattributes against the current HttpServletRequest.

22.8.5 LocaleChangeInterceptor

You can enable changing of locales by adding the LocaleChangeInterceptorto one of the handler mappings (see Section 22.4, “Handler mappings”). It will detect a parameter in the request and change the locale. It calls setLocale()on the LocaleResolverthat also exists in the context. The following example shows that calls to all *.viewresources containing a parameter named siteLanguagewill now change the locale. So, for example, a request for the following URL, http://www.sf.net/home.view?siteLanguage=nlwill change the site language to Dutch.

								<bean
								id=
								"localeChangeInterceptor"
								class=
								"org.springframework.web.servlet.i18n.LocaleChangeInterceptor"
								>
								<property
								name=
								"paramName"
								value=
								"siteLanguage"
								/>
								</bean>
								<bean
								id=
								"localeResolver"
								class=
								"org.springframework.web.servlet.i18n.CookieLocaleResolver"
								/>
								<bean
								id=
								"urlMapping"
								class=
								"org.springframework.web.servlet.handler.SimpleUrlHandlerMapping"
								>
								<property
								name=
								"interceptors"
								>
								<list>
								<ref
								bean=
								"localeChangeInterceptor"
								/>
								</list>
								</property>
								<property
								name=
								"mappings"
								>
								<value>/**/*.view=someController
								</value>
								</property>
								</bean>

22.9 Using themes

22.9.1 Overview of themes

You can apply Spring Web MVC framework themes to set the overall look-and-feel of your application, thereby enhancing user experience. A theme is a collection of static resources, typically style sheets and images, that affect the visual style of the application.

22.9.2 Defining themes

To use themes in your web application, you must set up an implementation of the org.springframework.ui.context.ThemeSourceinterface. The WebApplicationContextinterface extends ThemeSourcebut delegates its responsibilities to a dedicated implementation. By default the delegate will be an org.springframework.ui.context.support.ResourceBundleThemeSourceimplementation that loads properties files from the root of the classpath. To use a custom ThemeSourceimplementation or to configure the base name prefix of the ResourceBundleThemeSource, you can register a bean in the application context with the reserved name themeSource. The web application context automatically detects a bean with that name and uses it.

When using the ResourceBundleThemeSource, a theme is defined in a simple properties file. The properties file lists the resources that make up the theme. Here is an example:

styleSheet=/themes/cool/style.css background=/themes/cool/img/coolBg.jpg

The keys of the properties are the names that refer to the themed elements from view code. For a JSP, you typically do this using the spring:themecustom tag, which is very similar to the spring:messagetag. The following JSP fragment uses the theme defined in the previous example to customize the look and feel:

								<%@
								taglib
								prefix=
								"spring"
								uri=
								"http://www.springframework.org/tags"
								%>
								<html>
								<head>
								<link
								rel=
								"stylesheet"
								href=
								"<spring:theme code='styleSheet'/>"
								type=
								"text/css"
								/>
								</head>
								<body
								style=
								"background=<spring:theme code='background'/>"
								>...
								</body>
								</html>

By default, the ResourceBundleThemeSourceuses an empty base name prefix. As a result, the properties files are loaded from the root of the classpath. Thus you would put the cool.propertiestheme definition in a directory at the root of the classpath, for example, in /WEB-INF/classes. The ResourceBundleThemeSourceuses the standard Java resource bundle loading mechanism, allowing for full internationalization of themes. For example, we could have a /WEB-INF/classes/cool_nl.propertiesthat references a special background image with Dutch text on it.

22.9.3 Theme resolvers

After you define themes, as in the preceding section, you decide which theme to use. The DispatcherServletwill look for a bean named themeResolverto find out which ThemeResolverimplementation to use. A theme resolver works in much the same way as a LocaleResolver. It detects the theme to use for a particular request and can also alter the request’s theme. The following theme resolvers are provided by Spring:

Table 22.5. ThemeResolver implementations

Class Description

FixedThemeResolver

Selects a fixed theme, set using the defaultThemeNameproperty.

SessionThemeResolver

The theme is maintained in the user’s HTTP session. It only needs to be set once for each session, but is not persisted between sessions.

CookieThemeResolver

The selected theme is stored in a cookie on the client.

Spring also provides a ThemeChangeInterceptorthat allows theme changes on every request with a simple request parameter.

22.10 Spring’s multipart (file upload) support

22.10.1 Introduction

Spring’s built-in multipart support handles file uploads in web applications. You enable this multipart support with pluggable MultipartResolverobjects, defined in the org.springframework.web.multipartpackage. Spring provides one MultipartResolverimplementation for use with Commons FileUpload and another for use with Servlet 3.0 multipart request parsing.

By default, Spring does no multipart handling, because some developers want to handle multiparts themselves. You enable Spring multipart handling by adding a multipart resolver to the web application’s context. Each request is inspected to see if it contains a multipart. If no multipart is found, the request continues as expected. If a multipart is found in the request, the MultipartResolverthat has been declared in your context is used. After that, the multipart attribute in your request is treated like any other attribute.

22.10.2 Using a MultipartResolver with Commons FileUpload

The following example shows how to use the CommonsMultipartResolver:

								<bean
								id=
								"multipartResolver"
								class=
								"org.springframework.web.multipart.commons.CommonsMultipartResolver"
								>
								<!-- one of the properties available; the maximum file size in bytes -->
								<property
								name=
								"maxUploadSize"
								value=
								"100000"
								/>
								</bean>

Of course you also need to put the appropriate jars in your classpath for the multipart resolver to work. In the case of the CommonsMultipartResolver, you need to use commons-fileupload.jar.

When the Spring DispatcherServletdetects a multi-part request, it activates the resolver that has been declared in your context and hands over the request. The resolver then wraps the current HttpServletRequestinto a MultipartHttpServletRequestthat supports multipart file uploads. Using the MultipartHttpServletRequest, you can get information about the multiparts contained by this request and actually get access to the multipart files themselves in your controllers.

22.10.3 Using a MultipartResolver with Servlet 3.0

In order to use Servlet 3.0 based multipart parsing, you need to mark the DispatcherServletwith a "multipart-config"section in web.xml, or with a javax.servlet.MultipartConfigElementin programmatic Servlet registration, or in case of a custom Servlet class possibly with a javax.servlet.annotation.MultipartConfigannotation on your Servlet class. Configuration settings such as maximum sizes or storage locations need to be applied at that Servlet registration level as Servlet 3.0 does not allow for those settings to be done from the MultipartResolver.

Once Servlet 3.0 multipart parsing has been enabled in one of the above mentioned ways you can add the StandardServletMultipartResolverto your Spring configuration:

								<bean
								id=
								"multipartResolver"
								class=
								"org.springframework.web.multipart.support.StandardServletMultipartResolver"
								>
								</bean>

22.10.4 Handling a file upload in a form

After the MultipartResolvercompletes its job, the request is processed like any other. First, create a form with a file input that will allow the user to upload a form. The encoding attribute ( enctype="multipart/form-data") lets the browser know how to encode the form as multipart request:

								<html>
								<head>
								<title>Upload a file please
								</title>
								</head>
								<body>
								<h1>Please upload a file
								</h1>
								<form
								method=
								"post"
								action=
								"/form"
								enctype=
								"multipart/form-data"
								>
								<input
								type=
								"text"
								name=
								"name"
								/>
								<input
								type=
								"file"
								name=
								"file"
								/>
								<input
								type=
								"submit"
								/>
								</form>
								</body>
								</html>

The next step is to create a controller that handles the file upload. This controller is very similar to a normal annotated @Controller, except that we use MultipartHttpServletRequestor MultipartFilein the method parameters:

								
									@Controller
								public
								classFileUploadController {
								
									@PostMapping("/form")
								publicString handleFormUpload(
								
									@RequestParam("name")String name,
								
									@RequestParam("file")MultipartFile file) {
								if(!file.isEmpty()) {
								byte[] bytes = file.getBytes();
								// store the bytes somewhere
								return
								"redirect:uploadSuccess"; }
								return
								"redirect:uploadFailure"; } }

Note how the @RequestParammethod parameters map to the input elements declared in the form. In this example, nothing is done with the byte[], but in practice you can save it in a database, store it on the file system, and so on.

When using Servlet 3.0 multipart parsing you can also use javax.servlet.http.Partfor the method parameter:

								
									@Controller
								public
								classFileUploadController {
								
									@PostMapping("/form")
								publicString handleFormUpload(
								
									@RequestParam("name")String name,
								
									@RequestParam("file")Part file) { InputStream inputStream = file.getInputStream();
								// store bytes from uploaded file somewhere
								return
								"redirect:uploadSuccess"; } }

22.10.5 Handling a file upload request from programmatic clients

Multipart requests can also be submitted from non-browser clients in a RESTful service scenario. All of the above examples and configuration apply here as well. However, unlike browsers that typically submit files and simple form fields, a programmatic client can also send more complex data of a specific content type — for example a multipart request with a file and second part with JSON formatted data:

POST /someUrl Content-Type: multipart/mixed --edt7Tfrdusa7r3lNQc79vXuhIIMlatb7PQg7Vp Content-Disposition: form-data; name="meta-data" Content-Type: application/json; charset=UTF-8 Content-Transfer-Encoding: 8bit { "name": "value" } --edt7Tfrdusa7r3lNQc79vXuhIIMlatb7PQg7Vp Content-Disposition: form-data; name="file-data"; filename="file.properties" Content-Type: text/xml Content-Transfer-Encoding: 8bit ... File Data ...

You could access the part named "meta-data" with a @RequestParam("meta-data") String metadatacontroller method argument. However, you would probably prefer to accept a strongly typed object initialized from the JSON formatted data in the body of the request part, very similar to the way @RequestBodyconverts the body of a non-multipart request to a target object with the help of an HttpMessageConverter.

You can use the @RequestPartannotation instead of the @RequestParamannotation for this purpose. It allows you to have the content of a specific multipart passed through an HttpMessageConvertertaking into consideration the 'Content-Type'header of the multipart:

								
									@PostMapping("/someUrl")
								publicString onSubmit(
								
									@RequestPart("meta-data") MetaData metadata, @RequestPart("file-data") MultipartFile file) {
								// ...}

Notice how MultipartFilemethod arguments can be accessed with @RequestParamor with @RequestPartinterchangeably. However, the @RequestPart("meta-data") MetaDatamethod argument in this case is read as JSON content based on its 'Content-Type'header and converted with the help of the MappingJackson2HttpMessageConverter.

22.11 Handling exceptions

22.11.1 HandlerExceptionResolver

Spring HandlerExceptionResolverimplementations deal with unexpected exceptions that occur during controller execution. A HandlerExceptionResolversomewhat resembles the exception mappings you can define in the web application descriptor web.xml. However, they provide a more flexible way to do so. For example they provide information about which handler was executing when the exception was thrown. Furthermore, a programmatic way of handling exceptions gives you more options for responding appropriately before the request is forwarded to another URL (the same end result as when you use the Servlet specific exception mappings).

Besides implementing the HandlerExceptionResolverinterface, which is only a matter of implementing the resolveException(Exception, Handler)method and returning a ModelAndView, you may also use the provided SimpleMappingExceptionResolveror create @ExceptionHandlermethods. The SimpleMappingExceptionResolverenables you to take the class name of any exception that might be thrown and map it to a view name. This is functionally equivalent to the exception mapping feature from the Servlet API, but it is also possible to implement more finely grained mappings of exceptions from different handlers. The @ExceptionHandlerannotation on the other hand can be used on methods that should be invoked to handle an exception. Such methods may be defined locally within an @Controlleror may apply to many @Controllerclasses when defined within an @ControllerAdviceclass. The following sections explain this in more detail.

22.11.2 @ExceptionHandler

The HandlerExceptionResolverinterface and the SimpleMappingExceptionResolverimplementations allow you to map Exceptions to specific views declaratively along with some optional Java logic before forwarding to those views. However, in some cases, especially when relying on @ResponseBodymethods rather than on view resolution, it may be more convenient to directly set the status of the response and optionally write error content to the body of the response.

You can do that with @ExceptionHandlermethods. When declared within a controller such methods apply to exceptions raised by @RequestMappingmethods of that controller (or any of its sub-classes). You can also declare an @ExceptionHandlermethod within an @ControllerAdviceclass in which case it handles exceptions from @RequestMappingmethods from many controllers. Below is an example of a controller-local @ExceptionHandlermethod:

								
									@Controller
								public
								classSimpleController {
								// @RequestMapping methods omitted ...
								
									@ExceptionHandler(IOException.class)
								publicResponseEntity<String> handleIOException(IOException ex) {
								// prepare responseEntity
								returnresponseEntity; } }

The @ExceptionHandlervalue can be set to an array of Exception types. If an exception is thrown that matches one of the types in the list, then the method annotated with the matching @ExceptionHandlerwill be invoked. If the annotation value is not set then the exception types listed as method arguments are used.

Much like standard controller methods annotated with a @RequestMappingannotation, the method arguments and return values of @ExceptionHandlermethods can be flexible. For example, the HttpServletRequestcan be accessed in Servlet environments and the PortletRequestin Portlet environments. The return type can be a String, which is interpreted as a view name, a ModelAndViewobject, a ResponseEntity, or you can also add the @ResponseBodyto have the method return value converted with message converters and written to the response stream.

22.11.3 Handling Standard Spring MVC Exceptions

Spring MVC may raise a number of exceptions while processing a request. The SimpleMappingExceptionResolvercan easily map any exception to a default error view as needed. However, when working with clients that interpret responses in an automated way you will want to set specific status code on the response. Depending on the exception raised the status code may indicate a client error (4xx) or a server error (5xx).

The DefaultHandlerExceptionResolvertranslates Spring MVC exceptions to specific error status codes. It is registered by default with the MVC namespace, the MVC Java config, and also by the DispatcherServlet(i.e. when not using the MVC namespace or Java config). Listed below are some of the exceptions handled by this resolver and the corresponding status codes:

Exception HTTP Status Code

BindException

400 (Bad Request)

ConversionNotSupportedException

500 (Internal Server Error)

HttpMediaTypeNotAcceptableException

406 (Not Acceptable)

HttpMediaTypeNotSupportedException

415 (Unsupported Media Type)

HttpMessageNotReadableException

400 (Bad Request)

HttpMessageNotWritableException

500 (Internal Server Error)

HttpRequestMethodNotSupportedException

405 (Method Not Allowed)

MethodArgumentNotValidException

400 (Bad Request)

MissingPathVariableException

500 (Internal Server Error)

MissingServletRequestParameterException

400 (Bad Request)

MissingServletRequestPartException

400 (Bad Request)

NoHandlerFoundException

404 (Not Found)

NoSuchRequestHandlingMethodException

404 (Not Found)

TypeMismatchException

400 (Bad Request)

The DefaultHandlerExceptionResolverworks transparently by setting the status of the response. However, it stops short of writing any error content to the body of the response while your application may need to add developer-friendly content to every error response for example when providing a REST API. You can prepare a ModelAndViewand render error content through view resolution — i.e. by configuring a ContentNegotiatingViewResolver, MappingJackson2JsonView, and so on. However, you may prefer to use @ExceptionHandlermethods instead.

If you prefer to write error content via @ExceptionHandlermethods you can extend ResponseEntityExceptionHandlerinstead. This is a convenient base for @ControllerAdviceclasses providing an @ExceptionHandlermethod to handle standard Spring MVC exceptions and return ResponseEntity. That allows you to customize the response and write error content with message converters. See the ResponseEntityExceptionHandlerjavadocs for more details.

22.11.4 Annotating Business Exceptions With @ResponseStatus

A business exception can be annotated with @ResponseStatus. When the exception is raised, the ResponseStatusExceptionResolverhandles it by setting the status of the response accordingly. By default the DispatcherServletregisters the ResponseStatusExceptionResolverand it is available for use.

22.11.5 Customizing the Default Servlet Container Error Page

When the status of the response is set to an error status code and the body of the response is empty, Servlet containers commonly render an HTML formatted error page. To customize the default error page of the container, you can declare an <error-page>element in web.xml. Up until Servlet 3, that element had to be mapped to a specific status code or exception type. Starting with Servlet 3 an error page does not need to be mapped, which effectively means the specified location customizes the default Servlet container error page.

								<error-page>
								<location>/error
								</location>
								</error-page>

Note that the actual location for the error page can be a JSP page or some other URL within the container including one handled through an @Controllermethod:

When writing error information, the status code and the error message set on the HttpServletResponsecan be accessed through request attributes in a controller:

								
									@Controller
								public
								classErrorController {
								
									@RequestMapping(path = "/error", produces = MediaType.APPLICATION_JSON_UTF8_VALUE)
								
									@ResponseBody
								publicMap<String, Object> handle(HttpServletRequest request) { Map<String, Object> map =
								newHashMap<String, Object>(); map.put(
								"status", request.getAttribute(
								"javax.servlet.error.status_code")); map.put(
								"reason", request.getAttribute(
								"javax.servlet.error.message"));
								returnmap; } }

or in a JSP:

								<%@
								page
								contentType=
								"application/json"
								pageEncoding=
								"UTF-8"
								%>
								{
								status:<%=
								request.getAttribute("javax.servlet.error.status_code")
								%>,
								reason:<%=
								request.getAttribute("javax.servlet.error.message")
								%>
								}

22.12 Web Security

The Spring Securityproject provides features to protect web applications from malicious exploits. Check out the reference documentation in the sections on "CSRF protection", "Security Response Headers", and also "Spring MVC Integration". Note that using Spring Security to secure the application is not necessarily required for all features. For example CSRF protection can be added simply by adding the CsrfFilterand CsrfRequestDataValueProcessorto your configuration. See the Spring MVC Showcasefor an example.

Another option is to use a framework dedicated to Web Security. HDIVis one such framework and integrates with Spring MVC.

22.13 Convention over configuration support

For a lot of projects, sticking to established conventions and having reasonable defaults is just what they (the projects) need, and Spring Web MVC now has explicit support for convention over configuration. What this means is that if you establish a set of naming conventions and suchlike, you can substantiallycut down on the amount of configuration that is required to set up handler mappings, view resolvers, ModelAndViewinstances, etc. This is a great boon with regards to rapid prototyping, and can also lend a degree of (always good-to-have) consistency across a codebase should you choose to move forward with it into production.

Convention-over-configuration support addresses the three core areas of MVC: models, views, and controllers.

22.13.1 The Controller ControllerClassNameHandlerMapping

The ControllerClassNameHandlerMappingclass is a HandlerMappingimplementation that uses a convention to determine the mapping between request URLs and the Controllerinstances that are to handle those requests.

Consider the following simple Controllerimplementation. Take special notice of the nameof the class.

								public
								class
								
									ViewShoppingCartController
								implementsController {
								publicModelAndView handleRequest(HttpServletRequest request, HttpServletResponse response) {
								// the implementation is not hugely important for this example...} }

Here is a snippet from the corresponding Spring Web MVC configuration file:

								<bean
								class=
								"org.springframework.web.servlet.mvc.support.ControllerClassNameHandlerMapping"
								/>
								<bean
								id=
								"
								
									viewShoppingCart" class="x.y.z.ViewShoppingCartController">
								<!-- inject dependencies as required... -->
								</bean>

The ControllerClassNameHandlerMappingfinds all of the various handler (or Controller) beans defined in its application context and strips Controlleroff the name to define its handler mappings. Thus, ViewShoppingCartControllermaps to the /viewshoppingcart*request URL.

Let’s look at some more examples so that the central idea becomes immediately familiar. (Notice all lowercase in the URLs, in contrast to camel-cased Controllerclass names.)

  • WelcomeControllermaps to the /welcome*request URL
  • HomeControllermaps to the /home*request URL
  • IndexControllermaps to the /index*request URL
  • RegisterControllermaps to the /register*request URL

In the case of MultiActionControllerhandler classes, the mappings generated are slightly more complex. The Controllernames in the following examples are assumed to be MultiActionControllerimplementations:

  • AdminControllermaps to the /admin/*request URL
  • CatalogControllermaps to the /catalog/*request URL

If you follow the convention of naming your Controllerimplementations as xxxController, the ControllerClassNameHandlerMappingsaves you the tedium of defining and maintaining a potentially looooong SimpleUrlHandlerMapping(or suchlike).

The ControllerClassNameHandlerMappingclass extends the AbstractHandlerMappingbase class so you can define HandlerInterceptorinstances and everything else just as you would with many other HandlerMappingimplementations.

22.13.2 The Model ModelMap (ModelAndView)

The ModelMapclass is essentially a glorified Mapthat can make adding objects that are to be displayed in (or on) a Viewadhere to a common naming convention. Consider the following Controllerimplementation; notice that objects are added to the ModelAndViewwithout any associated name specified.

								public
								classDisplayShoppingCartController
								implementsController {
								publicModelAndView handleRequest(HttpServletRequest request, HttpServletResponse response) { List cartItems =
								// get a List of CartItem objectsUser user =
								// get the User doing the shoppingModelAndView mav =
								newModelAndView(
								"displayShoppingCart"); <-- the logical view name mav.addObject(cartItems); <-- look ma, no name, just the object mav.addObject(user); <-- and again ma!
								returnmav; } }

The ModelAndViewclass uses a ModelMapclass that is a custom Mapimplementation that automatically generates a key for an object when an object is added to it. The strategy for determining the name for an added object is, in the case of a scalar object such as User, to use the short class name of the object’s class. The following examples are names that are generated for scalar objects put into a ModelMapinstance.

  • An x.y.Userinstance added will have the name usergenerated.
  • An x.y.Registrationinstance added will have the name registrationgenerated.
  • An x.y.Fooinstance added will have the name foogenerated.
  • A java.util.HashMapinstance added will have the name hashMapgenerated. You probably want to be explicit about the name in this case because hashMapis less than intuitive.
  • Adding nullwill result in an IllegalArgumentExceptionbeing thrown. If the object (or objects) that you are adding could be null, then you will also want to be explicit about the name.

What, no automatic pluralization?

Spring Web MVC’s convention-over-configuration support does not support automatic pluralization. That is, you cannot add a Listof Personobjects to a ModelAndViewand have the generated name be people.

This decision was made after some debate, with the "Principle of Least Surprise" winning out in the end.

The strategy for generating a name after adding a Setor a Listis to peek into the collection, take the short class name of the first object in the collection, and use that with Listappended to the name. The same applies to arrays although with arrays it is not necessary to peek into the array contents. A few examples will make the semantics of name generation for collections clearer:

  • An x.y.User[]array with zero or more x.y.Userelements added will have the name userListgenerated.
  • An x.y.Foo[]array with zero or more x.y.Userelements added will have the name fooListgenerated.
  • A java.util.ArrayListwith one or more x.y.Userelements added will have the name userListgenerated.
  • A java.util.HashSetwith one or more x.y.Fooelements added will have the name fooListgenerated.
  • An empty java.util.ArrayListwill not be added at all (in effect, the addObject(..)call will essentially be a no-op).

22.13.3 The View - RequestToViewNameTranslator

The RequestToViewNameTranslatorinterface determines a logical Viewname when no such logical view name is explicitly supplied. It has just one implementation, the DefaultRequestToViewNameTranslatorclass.

The DefaultRequestToViewNameTranslatormaps request URLs to logical view names, as with this example:

								public
								classRegistrationController
								implementsController {
								publicModelAndView handleRequest(HttpServletRequest request, HttpServletResponse response) {
								// process the request...ModelAndView mav =
								newModelAndView();
								// add data as necessary to the model...
								returnmav;
								// notice that no View or logical view name has been set} }
								<?xml version="1.0" encoding="UTF-8"?>
								<beans
								xmlns=
								"http://www.springframework.org/schema/beans"
								xmlns:xsi=
								"http://www.w3.org/2001/XMLSchema-instance"
								xsi:schemaLocation=
								" http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd"
								>
								<!-- this bean with the well known name generates view names for us -->
								<bean
								id=
								"viewNameTranslator"
								class=
								"org.springframework.web.servlet.view.DefaultRequestToViewNameTranslator"
								/>
								<bean
								class=
								"x.y.RegistrationController"
								>
								<!-- inject dependencies as necessary -->
								</bean>
								<!-- maps request URLs to Controller names -->
								<bean
								class=
								"org.springframework.web.servlet.mvc.support.ControllerClassNameHandlerMapping"
								/>
								<bean
								id=
								"viewResolver"
								class=
								"org.springframework.web.servlet.view.InternalResourceViewResolver"
								>
								<property
								name=
								"prefix"
								value=
								"/WEB-INF/jsp/"
								/>
								<property
								name=
								"suffix"
								value=
								".jsp"
								/>
								</bean>
								</beans>

Notice how in the implementation of the handleRequest(..)method no Viewor logical view name is ever set on the ModelAndViewthat is returned. The DefaultRequestToViewNameTranslatoris tasked with generating a logical view namefrom the URL of the request. In the case of the above RegistrationController, which is used in conjunction with the ControllerClassNameHandlerMapping, a request URL of http://localhost/registration.htmlresults in a logical view name of registrationbeing generated by the DefaultRequestToViewNameTranslator. This logical view name is then resolved into the /WEB-INF/jsp/registration.jspview by the InternalResourceViewResolverbean.

[Tip] Tip

You do not need to define a DefaultRequestToViewNameTranslatorbean explicitly. If you like the default settings of the DefaultRequestToViewNameTranslator, you can rely on the Spring Web MVC DispatcherServletto instantiate an instance of this class if one is not explicitly configured.

Of course, if you need to change the default settings, then you do need to configure your own DefaultRequestToViewNameTranslatorbean explicitly. Consult the comprehensive DefaultRequestToViewNameTranslatorjavadocs for details on the various properties that can be configured.

22.14 HTTP caching support

A good HTTP caching strategy can significantly improve the performance of a web application and the experience of its clients. The 'Cache-Control'HTTP response header is mostly responsible for this, along with conditional headers such as 'Last-Modified'and 'ETag'.

The 'Cache-Control'HTTP response header advises private caches (e.g. browsers) and public caches (e.g. proxies) on how they can cache HTTP responses for further reuse.

An ETag(entity tag) is an HTTP response header returned by an HTTP/1.1 compliant web server used to determine change in content at a given URL. It can be considered to be the more sophisticated successor to the Last-Modifiedheader. When a server returns a representation with an ETag header, the client can use this header in subsequent GETs, in an If-None-Matchheader. If the content has not changed, the server returns 304: Not Modified.

This section describes the different choices available to configure HTTP caching in a Spring Web MVC application.

22.14.1 Cache-Control HTTP header

Spring Web MVC supports many use cases and ways to configure "Cache-Control" headers for an application. While RFC 7234 Section 5.2.2completely describes that header and its possible directives, there are several ways to address the most common cases.

Spring Web MVC uses a configuration convention in several of its APIs: setCachePeriod(int seconds):

  • A -1value won’t generate a 'Cache-Control'response header.
  • A 0value will prevent caching using the 'Cache-Control: no-store'directive.
  • An n > 0value will cache the given response for nseconds using the 'Cache-Control: max-age=n'directive.

The CacheControlbuilder class simply describes the available "Cache-Control" directives and makes it easier to build your own HTTP caching strategy. Once built, a CacheControlinstance can then be accepted as an argument in several Spring Web MVC APIs.

								// Cache for an hour - "Cache-Control: max-age=3600"CacheControl ccCacheOneHour = CacheControl.maxAge(
								1, TimeUnit.HOURS);
								// Prevent caching - "Cache-Control: no-store"CacheControl ccNoStore = CacheControl.noStore();
								// Cache for ten days in public and private caches,
								// public caches should not transform the response
								// "Cache-Control: max-age=864000, public, no-transform"CacheControl ccCustom = CacheControl.maxAge(
								10, TimeUnit.DAYS) .noTransform().cachePublic();

22.14.2 HTTP caching support for static resources

Static resources should be served with appropriate 'Cache-Control'and conditional headers for optimal performance. Configuring a ResourceHttpRequestHandlerfor serving static resources not only natively writes 'Last-Modified'headers by reading a file’s metadata, but also 'Cache-Control'headers if properly configured.

You can set the cachePeriodattribute on a ResourceHttpRequestHandleror use a CacheControlinstance, which supports more specific directives:

								
									@Configuration
								
									@EnableWebMvc
								public
								classWebConfig
								extendsWebMvcConfigurerAdapter {
								
									@Override
								public
								voidaddResourceHandlers(ResourceHandlerRegistry registry) { registry.addResourceHandler(
								"/resources/**") .addResourceLocations(
								"/public-resources/") .setCacheControl(CacheControl.maxAge(
								1, TimeUnit.HOURS).cachePublic()); } }

And in XML:

								<mvc:resources
								mapping=
								"/resources/**"
								location=
								"/public-resources/"
								>
								<mvc:cache-control
								max-age=
								"3600"
								cache-public=
								"true"
								/>
								</mvc:resources>

22.14.3 Support for the Cache-Control, ETag and Last-Modified response headers in Controllers

Controllers can support 'Cache-Control', 'ETag', and/or 'If-Modified-Since'HTTP requests; this is indeed recommended if a 'Cache-Control'header is to be set on the response. This involves calculating a lastModified longand/or an Etag value for a given request, comparing it against the 'If-Modified-Since'request header value, and potentially returning a response with status code 304 (Not Modified).

As described in the section called “Using HttpEntity”, controllers can interact with the request/response using HttpEntitytypes. Controllers returning ResponseEntitycan include HTTP caching information in responses like this:

								
									@GetMapping("/book/{id}")
								publicResponseEntity<Book> showBook(
								
									@PathVariableLong id) { Book book = findBook(id); String version = book.getVersion();
								returnResponseEntity .ok() .cacheControl(CacheControl.maxAge(
								30, TimeUnit.DAYS)) .eTag(version)
								// lastModified is also available.body(book); }

Doing this will not only include 'ETag'and 'Cache-Control'headers in the response, it will also convert the response to an HTTP 304 Not Modifiedresponse with an empty bodyif the conditional headers sent by the client match the caching information set by the Controller.

An @RequestMappingmethod may also wish to support the same behavior. This can be achieved as follows:

								
									@RequestMapping
								publicString myHandleMethod(WebRequest webRequest, Model model) {
								longlastModified =
								// 1. application-specific calculation
								if(request.checkNotModified(lastModified)) {
								// 2. shortcut exit - no further processing necessary
								returnnull; }
								// 3. or otherwise further request processing, actually preparing contentmodel.addAttribute(...);
								return
								"myViewName"; }

There are two key elements here: calling request.checkNotModified(lastModified)and returning null. The former sets the appropriate response status and headers before it returns true. The latter, in combination with the former, causes Spring MVC to do no further processing of the request.

Note that there are 3 variants for this:

  • request.checkNotModified(lastModified)compares lastModified with the 'If-Modified-Since'or 'If-Unmodified-Since'request header
  • request.checkNotModified(eTag)compares eTag with the 'If-None-Match'request header
  • request.checkNotModified(eTag, lastModified)does both, meaning that both conditions should be valid

When receiving conditional 'GET'/ 'HEAD'requests, checkNotModifiedwill check that the resource has not been modified and if so, it will result in a HTTP 304 Not Modifiedresponse. In case of conditional 'POST'/ 'PUT'/ 'DELETE'requests, checkNotModifiedwill check that the resource has not been modified and if it has been, it will result in a HTTP 409 Precondition Failedresponse to prevent concurrent modifications.

22.14.4 Shallow ETag support

Support for ETags is provided by the Servlet filter ShallowEtagHeaderFilter. It is a plain Servlet Filter, and thus can be used in combination with any web framework. The ShallowEtagHeaderFilterfilter creates so-called shallow ETags (as opposed to deep ETags, more about that later).The filter caches the content of the rendered JSP (or other content), generates an MD5 hash over that, and returns that as an ETag header in the response. The next time a client sends a request for the same resource, it uses that hash as the If-None-Matchvalue. The filter detects this, renders the view again, and compares the two hashes. If they are equal, a 304is returned.

Note that this strategy saves network bandwidth but not CPU, as the full response must be computed for each request. Other strategies at the controller level (described above) can save network bandwidth and avoid computation.

This filter has a writeWeakETagparameter that configures the filter to write Weak ETags, like this: W/"02a2d595e6ed9a0b24f027f2b63b134d6", as defined in RFC 7232 Section 2.3.

You configure the ShallowEtagHeaderFilterin web.xml:

								<filter>
								<filter-name>etagFilter
								</filter-name>
								<filter-class>org.springframework.web.filter.ShallowEtagHeaderFilter
								</filter-class>
								<!-- Optional parameter that configures the filter to write weak ETags <init-param> <param-name>writeWeakETag</param-name> <param-value>true</param-value> </init-param> -->
								</filter>
								<filter-mapping>
								<filter-name>etagFilter
								</filter-name>
								<servlet-name>petclinic
								</servlet-name>
								</filter-mapping>

Or in Servlet 3.0+ environments,

								public
								classMyWebAppInitializer
								extendsAbstractDispatcherServletInitializer {
								// ...
								
									@Override
								protectedFilter[] getServletFilters() {
								return
								newFilter[] {
								newShallowEtagHeaderFilter() }; } }

See Section 22.15, “Code-based Servlet container initialization”for more details.

22.15 Code-based Servlet container initialization

In a Servlet 3.0+ environment, you have the option of configuring the Servlet container programmatically as an alternative or in combination with a web.xmlfile. Below is an example of registering a DispatcherServlet:

							importorg.springframework.web.WebApplicationInitializer;
							public
							classMyWebApplicationInitializer
							implementsWebApplicationInitializer {
							
								@Override
							public
							voidonStartup(ServletContext container) { XmlWebApplicationContext appContext =
							newXmlWebApplicationContext(); appContext.setConfigLocation(
							"/WEB-INF/spring/dispatcher-config.xml"); ServletRegistration.Dynamic registration = container.addServlet(
							"dispatcher",
							newDispatcherServlet(appContext)); registration.setLoadOnStartup(
							1); registration.addMapping(
							"/"); } }

WebApplicationInitializeris an interface provided by Spring MVC that ensures your implementation is detected and automatically used to initialize any Servlet 3 container. An abstract base class implementation of WebApplicationInitializernamed AbstractDispatcherServletInitializermakes it even easier to register the DispatcherServletby simply overriding methods to specify the servlet mapping and the location of the DispatcherServletconfiguration.

This is recommended for applications that use Java-based Spring configuration:

							public
							classMyWebAppInitializer
							extendsAbstractAnnotationConfigDispatcherServletInitializer {
							
								@Override
							protectedClass<?>[] getRootConfigClasses() {
							returnnull; }
							
								@Override
							protectedClass<?>[] getServletConfigClasses() {
							return
							newClass[] { MyWebConfig.
							class}; }
							
								@Override
							protectedString[] getServletMappings() {
							return
							newString[] {
							"/"}; } }

If using XML-based Spring configuration, you should extend directly from AbstractDispatcherServletInitializer:

							public
							classMyWebAppInitializer
							extendsAbstractDispatcherServletInitializer {
							
								@Override
							protectedWebApplicationContext createRootApplicationContext() {
							returnnull; }
							
								@Override
							protectedWebApplicationContext createServletApplicationContext() { XmlWebApplicationContext cxt =
							newXmlWebApplicationContext(); cxt.setConfigLocation(
							"/WEB-INF/spring/dispatcher-config.xml");
							returncxt; }
							
								@Override
							protectedString[] getServletMappings() {
							return
							newString[] {
							"/"}; } }

AbstractDispatcherServletInitializeralso provides a convenient way to add Filterinstances and have them automatically mapped to the DispatcherServlet:

							public
							classMyWebAppInitializer
							extendsAbstractDispatcherServletInitializer {
							// ...
							
								@Override
							protectedFilter[] getServletFilters() {
							return
							newFilter[] {
							newHiddenHttpMethodFilter(),
							newCharacterEncodingFilter() }; } }

Each filter is added with a default name based on its concrete type and automatically mapped to the DispatcherServlet.

The isAsyncSupportedprotected method of AbstractDispatcherServletInitializerprovides a single place to enable async support on the DispatcherServletand all filters mapped to it. By default this flag is set to true.

Finally, if you need to further customize the DispatcherServletitself, you can override the createDispatcherServletmethod.

22.16 Configuring Spring MVC

Section 22.2.1, “Special Bean Types In the WebApplicationContext”and Section 22.2.2, “Default DispatcherServlet Configuration”explained about Spring MVC’s special beans and the default implementations used by the DispatcherServlet. In this section you’ll learn about two additional ways of configuring Spring MVC. Namely the MVC Java config and the MVC XML namespace.

The MVC Java config and the MVC namespace provide similar default configuration that overrides the DispatcherServletdefaults. The goal is to spare most applications from having to create the same configuration and also to provide higher-level constructs for configuring Spring MVC that serve as a simple starting point and require little or no prior knowledge of the underlying configuration.

You can choose either the MVC Java config or the MVC namespace depending on your preference. Also as you will see further below, with the MVC Java config it is easier to see the underlying configuration as well as to make fine-grained customizations directly to the created Spring MVC beans. But let’s start from the beginning.

22.16.1 Enabling the MVC Java Config or the MVC XML Namespace

To enable MVC Java config add the annotation @EnableWebMvcto one of your @Configurationclasses:

								
									@Configuration
								
									@EnableWebMvc
								public
								classWebConfig { }

To achieve the same in XML use the mvc:annotation-drivenelement in your DispatcherServlet context (or in your root context if you have no DispatcherServlet context defined):

								<?xml version="1.0" encoding="UTF-8"?>
								<beans
								xmlns=
								"http://www.springframework.org/schema/beans"
								xmlns:mvc=
								"http://www.springframework.org/schema/mvc"
								xmlns:xsi=
								"http://www.w3.org/2001/XMLSchema-instance"
								xsi:schemaLocation=
								" http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc.xsd"
								>
								<mvc:annotation-driven/>
								</beans>

The above registers a RequestMappingHandlerMapping, a RequestMappingHandlerAdapter, and an ExceptionHandlerExceptionResolver(among others) in support of processing requests with annotated controller methods using annotations such as @RequestMapping, @ExceptionHandler, and others.

It also enables the following:

  1. Spring 3 style type conversion through a ConversionServiceinstance in addition to the JavaBeans PropertyEditors used for Data Binding.
  2. Support for formattingNumber fields using the @NumberFormatannotation through the ConversionService.
  3. Support for formatting Date, Calendar, Long, and Joda Time fields using the @DateTimeFormatannotation.
  4. Support for validating @Controllerinputs with @Valid, if a JSR-303 Provider is present on the classpath.

  5. HttpMessageConvertersupport for @RequestBodymethod parameters and @ResponseBodymethod return values from @RequestMappingor @ExceptionHandlermethods.

    This is the complete list of HttpMessageConverters set up by mvc:annotation-driven:

    1. ByteArrayHttpMessageConverterconverts byte arrays.
    2. StringHttpMessageConverterconverts strings.
    3. ResourceHttpMessageConverterconverts to/from org.springframework.core.io.Resourcefor all media types.
    4. SourceHttpMessageConverterconverts to/from a javax.xml.transform.Source.
    5. FormHttpMessageConverterconverts form data to/from a MultiValueMap<String, String>.
    6. Jaxb2RootElementHttpMessageConverterconverts Java objects to/from XML — added if JAXB2 is present and Jackson 2 XML extension is not present on the classpath.
    7. MappingJackson2HttpMessageConverterconverts to/from JSON — added if Jackson 2 is present on the classpath.
    8. MappingJackson2XmlHttpMessageConverterconverts to/from XML — added if Jackson 2 XML extensionis present on the classpath.
    9. AtomFeedHttpMessageConverterconverts Atom feeds — added if Rome is present on the classpath.
    10. RssChannelHttpMessageConverterconverts RSS feeds — added if Rome is present on the classpath.

See Section 22.16.12, “Message Converters”for more information about how to customize these default converters.

[Note] Note

Jackson JSON and XML converters are created using ObjectMapperinstances created by Jackson2ObjectMapperBuilderin order to provide a better default configuration.

This builder customizes Jackson’s default properties with the following ones:

  1. DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIESis disabled.
  2. MapperFeature.DEFAULT_VIEW_INCLUSIONis disabled.

It also automatically registers the following well-known modules if they are detected on the classpath:

  1. jackson-datatype-jdk7: support for Java 7 types like java.nio.file.Path.
  2. jackson-datatype-joda: support for Joda-Time types.
  3. jackson-datatype-jsr310: support for Java 8 Date & Time API types.
  4. jackson-datatype-jdk8: support for other Java 8 types like Optional.

22.16.2 Customizing the Provided Configuration

To customize the default configuration in Java you simply implement the WebMvcConfigurerinterface or more likely extend the class WebMvcConfigurerAdapterand override the methods you need:

								
									@Configuration
								
									@EnableWebMvc
								public
								classWebConfig
								extendsWebMvcConfigurerAdapter {
								// Override configuration methods...}

To customize the default configuration of <mvc:annotation-driven/>check what attributes and sub-elements it supports. You can view the Spring MVC XML schemaor use the code completion feature of your IDE to discover what attributes and sub-elements are available.

22.16.3 Conversion and Formatting

By default formatters for Numberand Datetypes are installed, including support for the @NumberFormatand @DateTimeFormatannotations. Full support for the Joda Time formatting library is also installed if Joda Time is present on the classpath. To register custom formatters and converters, override the addFormattersmethod:

								
									@Configuration
								
									@EnableWebMvc
								public
								classWebConfig
								extendsWebMvcConfigurerAdapter {
								
									@Override
								public
								voidaddFormatters(FormatterRegistry registry) {
								// Add formatters and/or converters} }

In the MVC namespace the same defaults apply when <mvc:annotation-driven>is added. To register custom formatters and converters simply supply a ConversionService:

								<?xml version="1.0" encoding="UTF-8"?>
								<beans
								xmlns=
								"http://www.springframework.org/schema/beans"
								xmlns:mvc=
								"http://www.springframework.org/schema/mvc"
								xmlns:xsi=
								"http://www.w3.org/2001/XMLSchema-instance"
								xsi:schemaLocation=
								" http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc.xsd"
								>
								<mvc:annotation-driven
								conversion-service=
								"conversionService"
								/>
								<bean
								id=
								"conversionService"
								class=
								"org.springframework.format.support.FormattingConversionServiceFactoryBean"
								>
								<property
								name=
								"converters"
								>
								<set>
								<bean
								class=
								"org.example.MyConverter"
								/>
								</set>
								</property>
								<property
								name=
								"formatters"
								>
								<set>
								<bean
								class=
								"org.example.MyFormatter"
								/>
								<bean
								class=
								"org.example.MyAnnotationFormatterFactory"
								/>
								</set>
								</property>
								<property
								name=
								"formatterRegistrars"
								>
								<set>
								<bean
								class=
								"org.example.MyFormatterRegistrar"
								/>
								</set>
								</property>
								</bean>
								</beans>
[Note] Note

See Section 9.6.4, “FormatterRegistrar SPI”and the FormattingConversionServiceFactoryBeanfor more information on when to use FormatterRegistrars.

22.16.4 Validation

Spring provides a Validator interfacethat can be used for validation in all layers of an application. In Spring MVC you can configure it for use as a global Validatorinstance, to be used whenever an @Validor @Validatedcontroller method argument is encountered, and/or as a local Validatorwithin a controller through an @InitBindermethod. Global and local validator instances can be combined to provide composite validation.

Spring also supports JSR-303/JSR-349Bean Validation via LocalValidatorFactoryBeanwhich adapts the Spring org.springframework.validation.Validatorinterface to the Bean Validation javax.validation.Validatorcontract. This class can be plugged into Spring MVC as a global validator as described next.

By default use of @EnableWebMvcor <mvc:annotation-driven>automatically registers Bean Validation support in Spring MVC through the LocalValidatorFactoryBeanwhen a Bean Validation provider such as Hibernate Validator is detected on the classpath.

[Note] Note

Sometimes it’s convenient to have a LocalValidatorFactoryBeaninjected into a controller or another class. The easiest way to do that is to declare your own @Beanand also mark it with @Primaryin order to avoid a conflict with the one provided with the MVC Java config.

If you prefer to use the one from the MVC Java config, you’ll need to override the mvcValidatormethod from WebMvcConfigurationSupportand declare the method to explicitly return LocalValidatorFactoryrather than Validator. See Section 22.16.13, “Advanced Customizations with MVC Java Config”for information on how to switch to extend the provided configuration.

Alternatively you can configure your own global Validatorinstance:

								
									@Configuration
								
									@EnableWebMvc
								public
								classWebConfig
								extendsWebMvcConfigurerAdapter {
								
									@Override
								publicValidator getValidator(); {
								// return "global" validator} }

and in XML:

								<?xml version="1.0" encoding="UTF-8"?>
								<beans
								xmlns=
								"http://www.springframework.org/schema/beans"
								xmlns:mvc=
								"http://www.springframework.org/schema/mvc"
								xmlns:xsi=
								"http://www.w3.org/2001/XMLSchema-instance"
								xsi:schemaLocation=
								" http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc.xsd"
								>
								<mvc:annotation-driven
								validator=
								"globalValidator"
								/>
								</beans>

To combine global with local validation, simply add one or more local validator(s):

								
									@Controller
								public
								classMyController {
								
									@InitBinder
								protected
								voidinitBinder(WebDataBinder binder) { binder.addValidators(
								newFooValidator()); } }

With this minimal configuration any time an @Validor @Validatedmethod argument is encountered, it will be validated by the configured validators. Any validation violations will automatically be exposed as errors in the BindingResultaccessible as a method argument and also renderable in Spring MVC HTML views.

22.16.5 Interceptors

You can configure HandlerInterceptorsor WebRequestInterceptorsto be applied to all incoming requests or restricted to specific URL path patterns.

An example of registering interceptors in Java:

								
									@Configuration
								
									@EnableWebMvc
								public
								classWebConfig
								extendsWebMvcConfigurerAdapter {
								
									@Override
								public
								voidaddInterceptors(InterceptorRegistry registry) { registry.addInterceptor(
								newLocaleInterceptor()); registry.addInterceptor(
								newThemeInterceptor()).addPathPatterns(
								"/**").excludePathPatterns(
								"/admin/**"); registry.addInterceptor(
								newSecurityInterceptor()).addPathPatterns(
								"/secure/*"); } }

And in XML use the <mvc:interceptors>element:

								<mvc:interceptors>
								<bean
								class=
								"org.springframework.web.servlet.i18n.LocaleChangeInterceptor"
								/>
								<mvc:interceptor>
								<mvc:mapping
								path=
								"/**"
								/>
								<mvc:exclude-mapping
								path=
								"/admin/**"
								/>
								<bean
								class=
								"org.springframework.web.servlet.theme.ThemeChangeInterceptor"
								/>
								</mvc:interceptor>
								<mvc:interceptor>
								<mvc:mapping
								path=
								"/secure/*"
								/>
								<bean
								class=
								"org.example.SecurityInterceptor"
								/>
								</mvc:interceptor>
								</mvc:interceptors>

22.16.6 Content Negotiation

You can configure how Spring MVC determines the requested media types from the request. The available options are to check the URL path for a file extension, check the "Accept" header, a specific query parameter, or to fall back on a default content type when nothing is requested. By default the path extension in the request URI is checked first and the "Accept" header is checked second.

The MVC Java config and the MVC namespace register json, xml, rss, atomby default if corresponding dependencies are on the classpath. Additional path extension-to-media type mappings may also be registered explicitly and that also has the effect of whitelisting them as safe extensions for the purpose of RFD attack detection (see the section called “Suffix Pattern Matching and RFD”for more detail).

Below is an example of customizing content negotiation options through the MVC Java config:

								
									@Configuration
								
									@EnableWebMvc
								public
								classWebConfig
								extendsWebMvcConfigurerAdapter {
								
									@Override
								public
								voidconfigureContentNegotiation(ContentNegotiationConfigurer configurer) { configurer.mediaType(
								"json", MediaType.APPLICATION_JSON); } }

In the MVC namespace, the <mvc:annotation-driven>element has a content-negotiation-managerattribute, which expects a ContentNegotiationManagerthat in turn can be created with a ContentNegotiationManagerFactoryBean:

								<mvc:annotation-driven
								content-negotiation-manager=
								"contentNegotiationManager"
								/>
								<bean
								id=
								"contentNegotiationManager"
								class=
								"org.springframework.web.accept.ContentNegotiationManagerFactoryBean"
								>
								<property
								name=
								"mediaTypes"
								>
								<value>json=application/json xml=application/xml
								</value>
								</property>
								</bean>

If not using the MVC Java config or the MVC namespace, you’ll need to create an instance of ContentNegotiationManagerand use it to configure RequestMappingHandlerMappingfor request mapping purposes, and RequestMappingHandlerAdapterand ExceptionHandlerExceptionResolverfor content negotiation purposes.

Note that ContentNegotiatingViewResolvernow can also be configured with a ContentNegotiationManager, so you can use one shared instance throughout Spring MVC.

In more advanced cases, it may be useful to configure multiple ContentNegotiationManagerinstances that in turn may contain custom ContentNegotiationStrategyimplementations. For example you could configure ExceptionHandlerExceptionResolverwith a ContentNegotiationManagerthat always resolves the requested media type to "application/json". Or you may want to plug a custom strategy that has some logic to select a default content type (e.g. either XML or JSON) if no content types were requested.

22.16.7 View Controllers

This is a shortcut for defining a ParameterizableViewControllerthat immediately forwards to a view when invoked. Use it in static cases when there is no Java controller logic to execute before the view generates the response.

An example of forwarding a request for "/"to a view called "home"in Java:

								
									@Configuration
								
									@EnableWebMvc
								public
								classWebConfig
								extendsWebMvcConfigurerAdapter {
								
									@Override
								public
								voidaddViewControllers(ViewControllerRegistry registry) { registry.addViewController(
								"/").setViewName(
								"home"); } }

And the same in XML use the <mvc:view-controller>element:

								<mvc:view-controller
								path=
								"/"
								view-name=
								"home"
								/>

22.16.8 View Resolvers

The MVC config simplifies the registration of view resolvers.

The following is a Java config example that configures content negotiation view resolution using FreeMarker HTML templates and Jackson as a default Viewfor JSON rendering:

								
									@Configuration
								
									@EnableWebMvc
								public
								classWebConfig
								extendsWebMvcConfigurerAdapter {
								
									@Override
								public
								voidconfigureViewResolvers(ViewResolverRegistry registry) { registry.enableContentNegotiation(
								newMappingJackson2JsonView()); registry.jsp(); } }

And the same in XML:

								<mvc:view-resolvers>
								<mvc:content-negotiation>
								<mvc:default-views>
								<bean
								class=
								"org.springframework.web.servlet.view.json.MappingJackson2JsonView"
								/>
								</mvc:default-views>
								</mvc:content-negotiation>
								<mvc:jsp/>
								</mvc:view-resolvers>

Note however that FreeMarker, Velocity, Tiles, Groovy Markup and script templates also require configuration of the underlying view technology.

The MVC namespace provides dedicated elements. For example with FreeMarker:

								<mvc:view-resolvers>
								<mvc:content-negotiation>
								<mvc:default-views>
								<bean
								class=
								"org.springframework.web.servlet.view.json.MappingJackson2JsonView"
								/>
								</mvc:default-views>
								</mvc:content-negotiation>
								<mvc:freemarker
								cache=
								"false"
								/>
								</mvc:view-resolvers>
								<mvc:freemarker-configurer>
								<mvc:template-loader-path
								location=
								"/freemarker"
								/>
								</mvc:freemarker-configurer>

In Java config simply add the respective "Configurer" bean:

								
									@Configuration
								
									@EnableWebMvc
								public
								classWebConfig
								extendsWebMvcConfigurerAdapter {
								
									@Override
								public
								voidconfigureViewResolvers(ViewResolverRegistry registry) { registry.enableContentNegotiation(
								newMappingJackson2JsonView()); registry.freeMarker().cache(false); }
								
									@Bean
								publicFreeMarkerConfigurer freeMarkerConfigurer() { FreeMarkerConfigurer configurer =
								newFreeMarkerConfigurer(); configurer.setTemplateLoaderPath(
								"/WEB-INF/");
								returnconfigurer; } }

22.16.9 Serving of Resources

This option allows static resource requests following a particular URL pattern to be served by a ResourceHttpRequestHandlerfrom any of a list of Resourcelocations. This provides a convenient way to serve static resources from locations other than the web application root, including locations on the classpath. The cache-periodproperty may be used to set far future expiration headers (1 year is the recommendation of optimization tools such as Page Speed and YSlow) so that they will be more efficiently utilized by the client. The handler also properly evaluates the Last-Modifiedheader (if present) so that a 304status code will be returned as appropriate, avoiding unnecessary overhead for resources that are already cached by the client. For example, to serve resource requests with a URL pattern of /resources/**from a public-resourcesdirectory within the web application root you would use:

								
									@Configuration
								
									@EnableWebMvc
								public
								classWebConfig
								extendsWebMvcConfigurerAdapter {
								
									@Override
								public
								voidaddResourceHandlers(ResourceHandlerRegistry registry) { registry.addResourceHandler(
								"/resources/**").addResourceLocations(
								"/public-resources/"); } }

And the same in XML:

								<mvc:resources
								mapping=
								"/resources/**"
								location=
								"/public-resources/"
								/>

To serve these resources with a 1-year future expiration to ensure maximum use of the browser cache and a reduction in HTTP requests made by the browser:

								
									@Configuration
								
									@EnableWebMvc
								public
								classWebConfig
								extendsWebMvcConfigurerAdapter {
								
									@Override
								public
								voidaddResourceHandlers(ResourceHandlerRegistry registry) { registry.addResourceHandler(
								"/resources/**").addResourceLocations(
								"/public-resources/").setCachePeriod(
								31556926); } }

And in XML:

								<mvc:resources
								mapping=
								"/resources/**"
								location=
								"/public-resources/"
								cache-period=
								"31556926"
								/>

For more details, see HTTP caching support for static resources.

The mappingattribute must be an Ant pattern that can be used by SimpleUrlHandlerMapping, and the locationattribute must specify one or more valid resource directory locations. Multiple resource locations may be specified using a comma-separated list of values. The locations specified will be checked in the specified order for the presence of the resource for any given request. For example, to enable the serving of resources from both the web application root and from a known path of /META-INF/public-web-resources/in any jar on the classpath use:

								
									@EnableWebMvc
								
									@Configuration
								public
								classWebConfig
								extendsWebMvcConfigurerAdapter {
								
									@Override
								public
								voidaddResourceHandlers(ResourceHandlerRegistry registry) { registry.addResourceHandler(
								"/resources/**") .addResourceLocations(
								"/",
								"classpath:/META-INF/public-web-resources/"); } }

And in XML:

								<mvc:resources
								mapping=
								"/resources/**"
								location=
								"/, classpath:/META-INF/public-web-resources/"
								/>

When serving resources that may change when a new version of the application is deployed it is recommended that you incorporate a version string into the mapping pattern used to request the resources so that you may force clients to request the newly deployed version of your application’s resources. Support for versioned URLs is built into the framework and can be enabled by configuring a resource chain on the resource handler. The chain consists of one more ResourceResolverinstances followed by one or more ResourceTransformerinstances. Together they can provide arbitrary resolution and transformation of resources.

The built-in VersionResourceResolvercan be configured with different strategies. For example a FixedVersionStrategycan use a property, a date, or other as the version. A ContentVersionStrategyuses an MD5 hash computed from the content of the resource (known as "fingerprinting" URLs). Note that the VersionResourceResolverwill automatically use the resolved version strings as HTTP ETag header values when serving resources.

ContentVersionStrategyis a good default choice to use except in cases where it cannot be used (e.g. with JavaScript module loaders). You can configure different version strategies against different patterns as shown below. Keep in mind also that computing content-based versions is expensive and therefore resource chain caching should be enabled in production.

Java config example;

								
									@Configuration
								
									@EnableWebMvc
								public
								classWebConfig
								extendsWebMvcConfigurerAdapter {
								
									@Override
								public
								voidaddResourceHandlers(ResourceHandlerRegistry registry) { registry.addResourceHandler(
								"/resources/**") .addResourceLocations(
								"/public-resources/") .resourceChain(true).addResolver(
								newVersionResourceResolver().addContentVersionStrategy(
								"/**")); } }

XML example:

								<mvc:resources
								mapping=
								"/resources/**"
								location=
								"/public-resources/"
								>
								<mvc:resource-chain>
								<mvc:resource-cache/>
								<mvc:resolvers>
								<mvc:version-resolver>
								<mvc:content-version-strategy
								patterns=
								"/**"
								/>
								</mvc:version-resolver>
								</mvc:resolvers>
								</mvc:resource-chain>
								</mvc:resources>

In order for the above to work the application must also render URLs with versions. The easiest way to do that is to configure the ResourceUrlEncodingFilterwhich wraps the response and overrides its encodeURLmethod. This will work in JSPs, FreeMarker, Velocity, and any other view technology that calls the response encodeURLmethod. Alternatively, an application can also inject and use directly the ResourceUrlProviderbean, which is automatically declared with the MVC Java config and the MVC namespace.

Webjars are also supported with WebJarsResourceResolver, which is automatically registered when the "org.webjars:webjars-locator"library is on classpath. This resolver allows the resource chain to resolve version agnostic libraries from HTTP GET requests "GET /jquery/jquery.min.js"will return resource "/jquery/1.2.0/jquery.min.js". It also works by rewriting resource URLs in templates <script src="/jquery/jquery.min.js"/> → <script src="/jquery/1.2.0/jquery.min.js"/>.

22.16.10 Falling Back On the "Default" Servlet To Serve Resources

This allows for mapping the DispatcherServletto "/" (thus overriding the mapping of the container’s default Servlet), while still allowing static resource requests to be handled by the container’s default Servlet. It configures a DefaultServletHttpRequestHandlerwith a URL mapping of "/**" and the lowest priority relative to other URL mappings.

This handler will forward all requests to the default Servlet. Therefore it is important that it remains last in the order of all other URL HandlerMappings. That will be the case if you use <mvc:annotation-driven>or alternatively if you are setting up your own customized HandlerMappinginstance be sure to set its orderproperty to a value lower than that of the DefaultServletHttpRequestHandler, which is Integer.MAX_VALUE.

To enable the feature using the default setup use:

								
									@Configuration
								
									@EnableWebMvc
								public
								classWebConfig
								extendsWebMvcConfigurerAdapter {
								
									@Override
								public
								voidconfigureDefaultServletHandling(DefaultServletHandlerConfigurer configurer) { configurer.enable(); } }

Or in XML:

								<mvc:default-servlet-handler/>

The caveat to overriding the "/" Servlet mapping is that the RequestDispatcherfor the default Servlet must be retrieved by name rather than by path. The DefaultServletHttpRequestHandlerwill attempt to auto-detect the default Servlet for the container at startup time, using a list of known names for most of the major Servlet containers (including Tomcat, Jetty, GlassFish, JBoss, Resin, WebLogic, and WebSphere). If the default Servlet has been custom configured with a different name, or if a different Servlet container is being used where the default Servlet name is unknown, then the default Servlet’s name must be explicitly provided as in the following example:

								
									@Configuration
								
									@EnableWebMvc
								public
								classWebConfig
								extendsWebMvcConfigurerAdapter {
								
									@Override
								public
								voidconfigureDefaultServletHandling(DefaultServletHandlerConfigurer configurer) { configurer.enable(
								"myCustomDefaultServlet"); } }

Or in XML:

								<mvc:default-servlet-handler
								default-servlet-name=
								"myCustomDefaultServlet"
								/>

22.16.11 Path Matching

This allows customizing various settings related to URL mapping and path matching. For details on the individual options check out the PathMatchConfigurerAPI.

Below is an example in Java config:

								
									@Configuration
								
									@EnableWebMvc
								public
								classWebConfig
								extendsWebMvcConfigurerAdapter {
								
									@Override
								public
								voidconfigurePathMatch(PathMatchConfigurer configurer) { configurer .setUseSuffixPatternMatch(true) .setUseTrailingSlashMatch(false) .setUseRegisteredSuffixPatternMatch(true) .setPathMatcher(antPathMatcher()) .setUrlPathHelper(urlPathHelper()); }
								
									@Bean
								publicUrlPathHelper urlPathHelper() {
								//...}
								
									@Bean
								publicPathMatcher antPathMatcher() {
								//...} }

And the same in XML, use the <mvc:path-matching>element:

								<mvc:annotation-driven>
								<mvc:path-matching
								suffix-pattern=
								"true"
								trailing-slash=
								"false"
								registered-suffixes-only=
								"true"
								path-helper=
								"pathHelper"
								path-matcher=
								"pathMatcher"
								/>
								</mvc:annotation-driven>
								<bean
								id=
								"pathHelper"
								class=
								"org.example.app.MyPathHelper"
								/>
								<bean
								id=
								"pathMatcher"
								class=
								"org.example.app.MyPathMatcher"
								/>

22.16.12 Message Converters

Customization of HttpMessageConvertercan be achieved in Java config by overriding configureMessageConverters()if you want to replace the default converters created by Spring MVC, or by overriding extendMessageConverters()if you just want to customize them or add additional converters to the default ones.

Below is an example that adds Jackson JSON and XML converters with a customized ObjectMapperinstead of default ones:

								
									@Configuration
								
									@EnableWebMvc
								public
								classWebConfiguration
								extendsWebMvcConfigurerAdapter {
								
									@Override
								public
								voidconfigureMessageConverters(List<HttpMessageConverter<?>> converters) { Jackson2ObjectMapperBuilder builder =
								newJackson2ObjectMapperBuilder() .indentOutput(true) .dateFormat(
								newSimpleDateFormat(
								"yyyy-MM-dd")) .modulesToInstall(
								newParameterNamesModule()); converters.add(
								newMappingJackson2HttpMessageConverter(builder.build())); converters.add(
								newMappingJackson2XmlHttpMessageConverter(builder.xml().build())); } }

In this example, Jackson2ObjectMapperBuilderis used to create a common configuration for both MappingJackson2HttpMessageConverterand MappingJackson2XmlHttpMessageConverterwith indentation enabled, a customized date format and the registration of jackson-module-parameter-namesthat adds support for accessing parameter names (feature added in Java 8).

[Note] Note

Enabling indentation with Jackson XML support requires woodstox-core-asldependency in addition to jackson-dataformat-xmlone.

Other interesting Jackson modules are available:

  1. jackson-datatype-money: support for javax.moneytypes (unofficial module)
  2. jackson-datatype-hibernate: support for Hibernate specific types and properties (including lazy-loading aspects)

It is also possible to do the same in XML:

								<mvc:annotation-driven>
								<mvc:message-converters>
								<bean
								class=
								"org.springframework.http.converter.json.MappingJackson2HttpMessageConverter"
								>
								<property
								name=
								"objectMapper"
								ref=
								"objectMapper"
								/>
								</bean>
								<bean
								class=
								"org.springframework.http.converter.xml.MappingJackson2XmlHttpMessageConverter"
								>
								<property
								name=
								"objectMapper"
								ref=
								"xmlMapper"
								/>
								</bean>
								</mvc:message-converters>
								</mvc:annotation-driven>
								<bean
								id=
								"objectMapper"
								class=
								"org.springframework.http.converter.json.Jackson2ObjectMapperFactoryBean"
								p:indentOutput=
								"true"
								p:simpleDateFormat=
								"yyyy-MM-dd"
								p:modulesToInstall=
								"com.fasterxml.jackson.module.paramnames.ParameterNamesModule"
								/>
								<bean
								id=
								"xmlMapper"
								parent=
								"objectMapper"
								p:createXmlMapper=
								"true"
								/>

22.16.13 Advanced Customizations with MVC Java Config

As you can see from the above examples, MVC Java config and the MVC namespace provide higher level constructs that do not require deep knowledge of the underlying beans created for you. Instead it helps you to focus on your application needs. However, at some point you may need more fine-grained control or you may simply wish to understand the underlying configuration.

The first step towards more fine-grained control is to see the underlying beans created for you. In MVC Java config you can see the javadocs and the @Beanmethods in WebMvcConfigurationSupport. The configuration in this class is automatically imported through the @EnableWebMvcannotation. In fact if you open @EnableWebMvcyou can see the @Importstatement.

The next step towards more fine-grained control is to customize a property on one of the beans created in WebMvcConfigurationSupportor perhaps to provide your own instance. This requires two things — remove the @EnableWebMvcannotation in order to prevent the import and then extend from DelegatingWebMvcConfiguration, a subclass of WebMvcConfigurationSupport. Here is an example:

								
									@Configuration
								public
								classWebConfig
								extendsDelegatingWebMvcConfiguration {
								
									@Override
								public
								voidaddInterceptors(InterceptorRegistry registry){
								// ...}
								
									@Override
								
									@Bean
								publicRequestMappingHandlerAdapter requestMappingHandlerAdapter() {
								// Create or let "super" create the adapter
								// Then customize one of its properties} }
[Note] Note

An application should have only one configuration extending DelegatingWebMvcConfigurationor a single @EnableWebMvcannotated class, since they both register the same underlying beans.

Modifying beans in this way does not prevent you from using any of the higher-level constructs shown earlier in this section. WebMvcConfigurerAdaptersubclasses and WebMvcConfigurerimplementations are still being used.

22.16.14 Advanced Customizations with the MVC Namespace

Fine-grained control over the configuration created for you is a bit harder with the MVC namespace.

If you do need to do that, rather than replicating the configuration it provides, consider configuring a BeanPostProcessorthat detects the bean you want to customize by type and then modifying its properties as necessary. For example:

								
									@Component
								public
								classMyPostProcessor
								implementsBeanPostProcessor {
								publicObject postProcessBeforeInitialization(Object bean, String name)
								throwsBeansException {
								if(bean
								instanceofRequestMappingHandlerAdapter) {
								// Modify properties of the adapter} } }

Note that MyPostProcessorneeds to be included in an <component scan/>in order for it to be detected or if you prefer you can declare it explicitly with an XML bean declaration.

23. View technologies

23.1 Introduction

One of the areas in which Spring excels is in the separation of view technologies from the rest of the MVC framework. For example, deciding to use Groovy Markup Templates or Thymeleaf in place of an existing JSP is primarily a matter of configuration. This chapter covers the major view technologies that work with Spring and touches briefly on how to add new ones. This chapter assumes you are already familiar with Section 22.5, “Resolving views”which covers the basics of how views in general are coupled to the MVC framework.

23.2 Thymeleaf

Thymeleafis a good example of a view technology fitting perfectly in the MVC framework. Support for this integration is not provided by the Spring team but by the Thymeleaf team itself.

Configuring Thymeleaf for Spring usually requires a few beans defined, like a ServletContextTemplateResolver, a SpringTemplateEngineand a ThymeleafViewResolver. Please refer to the Thymeleaf+Springdocumentation section for more details.

23.3 Groovy Markup Templates

The Groovy Markup Template Engineis another view technology, supported by Spring. This template engine is a template engine primarily aimed at generating XML-like markup (XML, XHTML, HTML5, …​​), but that can be used to generate any text based content.

This requires Groovy 2.3.1+ on the classpath.

23.3.1 Configuration

Configuring the Groovy Markup Template Engine is quite easy:

								
									@Configuration
								
									@EnableWebMvc
								public
								classWebConfig
								extendsWebMvcConfigurerAdapter {
								
									@Override
								public
								voidconfigureViewResolvers(ViewResolverRegistry registry) { registry.groovy(); }
								
									@Bean
								publicGroovyMarkupConfigurer groovyMarkupConfigurer() { GroovyMarkupConfigurer configurer =
								newGroovyMarkupConfigurer(); configurer.setResourceLoaderPath(
								"/WEB-INF/");
								returnconfigurer; } }

The XML counterpart using the MVC namespace is:

								<mvc:annotation-driven/>
								<mvc:view-resolvers>
								<mvc:groovy/>
								</mvc:view-resolvers>
								<mvc:groovy-configurer
								resource-loader-path=
								"/WEB-INF/"
								/>

23.3.2 Example

Unlike traditional template engines, this one relies on a DSL that uses the builder syntax. Here is a sample template for an HTML page:

yieldUnescaped
								'<!DOCTYPE html>'html(lang:
								'en') { head { meta(
								'http-equiv':
								'"Content-Type" content="text/html; charset=utf-8"') title(
								'My page') } body { p(
								'This is an example of HTML contents') } }

23.4 Velocity & FreeMarker

Velocityand FreeMarkerare two templating languages that can be used as view technologies within Spring MVC applications. The languages are quite similar and serve similar needs and so are considered together in this section. For semantic and syntactic differences between the two languages, see the FreeMarkerweb site.

[Note] Note

As of Spring Framework 4.3, Velocity support has been deprecated due to six years without active maintenance of the Apache Velocity project. We recommend Spring’s FreeMarker support instead, or Thymeleaf which comes with Spring support itself.

23.4.1 Dependencies

Your web application will need to include velocity-1.x.x.jaror freemarker-2.x.jarin order to work with Velocity or FreeMarker respectively and commons-collections.jaris required for Velocity. Typically they are included in the WEB-INF/libfolder where they are guaranteed to be found by a Java EE server and added to the classpath for your application. It is of course assumed that you already have the spring-webmvc.jarin your 'WEB-INF/lib'directory too! If you make use of Spring’s 'dateToolAttribute' or 'numberToolAttribute' in your Velocity views, you will also need to include the velocity-tools-generic-1.x.jar

23.4.2 Context configuration

A suitable configuration is initialized by adding the relevant configurer bean definition to your '*-servlet.xml'as shown below:

								<!-- This bean sets up the Velocity environment for us based on a root path for templates. Optionally, a properties file can be specified for more control over the Velocity environment, but the defaults are pretty sane for file based template loading. -->
								<bean
								id=
								"velocityConfig"
								class=
								"org.springframework.web.servlet.view.velocity.VelocityConfigurer"
								>
								<property
								name=
								"resourceLoaderPath"
								value=
								"/WEB-INF/velocity/"
								/>
								</bean>
								<!-- View resolvers can also be configured with ResourceBundles or XML files. If you need different view resolving based on Locale, you have to use the resource bundle resolver. -->
								<bean
								id=
								"viewResolver"
								class=
								"org.springframework.web.servlet.view.velocity.VelocityViewResolver"
								>
								<property
								name=
								"cache"
								value=
								"true"
								/>
								<property
								name=
								"prefix"
								value=
								""
								/>
								<property
								name=
								"suffix"
								value=
								".vm"
								/>
								</bean>
								<!-- freemarker config -->
								<bean
								id=
								"freemarkerConfig"
								class=
								"org.springframework.web.servlet.view.freemarker.FreeMarkerConfigurer"
								>
								<property
								name=
								"templateLoaderPath"
								value=
								"/WEB-INF/freemarker/"
								/>
								</bean>
								<!-- View resolvers can also be configured with ResourceBundles or XML files. If you need different view resolving based on Locale, you have to use the resource bundle resolver. -->
								<bean
								id=
								"viewResolver"
								class=
								"org.springframework.web.servlet.view.freemarker.FreeMarkerViewResolver"
								>
								<property
								name=
								"cache"
								value=
								"true"
								/>
								<property
								name=
								"prefix"
								value=
								""
								/>
								<property
								name=
								"suffix"
								value=
								".ftl"
								/>
								</bean>
[Note] Note

For non web-apps add a VelocityConfigurationFactoryBeanor a FreeMarkerConfigurationFactoryBeanto your application context definition file.

23.4.3 Creating templates

Your templates need to be stored in the directory specified by the *Configurerbean shown above. This document does not cover details of creating templates for the two languages - please see their relevant websites for information. If you use the view resolvers highlighted, then the logical view names relate to the template file names in similar fashion to InternalResourceViewResolverfor JSP’s. So if your controller returns a ModelAndView object containing a view name of "welcome" then the resolvers will look for the /WEB-INF/freemarker/welcome.ftlor /WEB-INF/velocity/welcome.vmtemplate as appropriate.

23.4.4 Advanced configuration

The basic configurations highlighted above will be suitable for most application requirements, however additional configuration options are available for when unusual or advanced requirements dictate.

velocity.properties

This file is completely optional, but if specified, contains the values that are passed to the Velocity runtime in order to configure velocity itself. Only required for advanced configurations, if you need this file, specify its location on the VelocityConfigurerbean definition above.

									<bean
									id=
									"velocityConfig"
									class=
									"org.springframework.web.servlet.view.velocity.VelocityConfigurer"
									>
									<property
									name=
									"configLocation"
									value=
									"/WEB-INF/velocity.properties"
									/>
									</bean>

Alternatively, you can specify velocity properties directly in the bean definition for the Velocity config bean by replacing the "configLocation" property with the following inline properties.

									<bean
									id=
									"velocityConfig"
									class=
									"org.springframework.web.servlet.view.velocity.VelocityConfigurer"
									>
									<property
									name=
									"velocityProperties"
									>
									<props>
									<prop
									key=
									"resource.loader"
									>file
									</prop>
									<prop
									key=
									"file.resource.loader.class"
									>org.apache.velocity.runtime.resource.loader.FileResourceLoader
									</prop>
									<prop
									key=
									"file.resource.loader.path"
									>${webapp.root}/WEB-INF/velocity
									</prop>
									<prop
									key=
									"file.resource.loader.cache"
									>false
									</prop>
									</props>
									</property>
									</bean>

Refer to the API documentationfor Spring configuration of Velocity, or the Velocity documentation for examples and definitions of the 'velocity.properties'file itself.

FreeMarker

FreeMarker 'Settings' and 'SharedVariables' can be passed directly to the FreeMarker Configurationobject managed by Spring by setting the appropriate bean properties on the FreeMarkerConfigurerbean. The freemarkerSettingsproperty requires a java.util.Propertiesobject and the freemarkerVariablesproperty requires a java.util.Map.

									<bean
									id=
									"freemarkerConfig"
									class=
									"org.springframework.web.servlet.view.freemarker.FreeMarkerConfigurer"
									>
									<property
									name=
									"templateLoaderPath"
									value=
									"/WEB-INF/freemarker/"
									/>
									<property
									name=
									"freemarkerVariables"
									>
									<map>
									<entry
									key=
									"xml_escape"
									value-ref=
									"fmXmlEscape"
									/>
									</map>
									</property>
									</bean>
									<bean
									id=
									"fmXmlEscape"
									class=
									"freemarker.template.utility.XmlEscape"
									/>

See the FreeMarker documentation for details of settings and variables as they apply to the Configurationobject.

23.4.5 Bind support and form handling

Spring provides a tag library for use in JSP’s that contains (amongst other things) a <spring:bind/>tag. This tag primarily enables forms to display values from form backing objects and to show the results of failed validations from a Validatorin the web or business tier. From version 1.1, Spring now has support for the same functionality in both Velocity and FreeMarker, with additional convenience macros for generating form input elements themselves.

The bind macros

A standard set of macros are maintained within the spring-webmvc.jarfile for both languages, so they are always available to a suitably configured application.

Some of the macros defined in the Spring libraries are considered internal (private) but no such scoping exists in the macro definitions making all macros visible to calling code and user templates. The following sections concentrate only on the macros you need to be directly calling from within your templates. If you wish to view the macro code directly, the files are called spring.vm / spring.ftl and are in the packages org.springframework.web.servlet.view.velocityor org.springframework.web.servlet.view.freemarkerrespectively.

Simple binding

In your HTML forms (vm / ftl templates) which act as a form view for a Spring MVC controller, you can use code similar to the following to bind to field values and display error messages for each input field in similar fashion to the JSP equivalent. Example code is shown below for the personFormV/ personFormFviews configured earlier:

									<!-- velocity macros are automatically available -->
									<html>...
									<form
									action=
									""
									method=
									"POST"
									>Name: #springBind("myModelObject.name")
									<input
									type=
									"text"
									name=
									"${status.expression}"
									value=
									"$!status.value"
									/>
									<br>#foreach($error in $status.errorMessages)
									<b>$error
									</b>
									<br>#end
									<br>...
									<input
									type=
									"submit"
									value=
									"submit"
									/>
									</form>...
									</html>
									<!-- freemarker macros have to be imported into a namespace. We strongly recommend sticking to 'spring' -->
									<#import
									"/spring.ftl"
									as
									spring/>
									<html>
									...
									<form
									action=
									""
									method=
									"POST"
									>Name:
									<@spring.bind
									"myModelObject.name"/>
									<input
									type=
									"text"
									name=
									"${spring.status.expression}"
									value=
									"${spring.status.value?html}"
									/>
									<br>
									<#list
									spring.status.errorMessages
									as
									error>
									<b>${error}</b>
									<br>
									</#list>
									<br>
									...
									<input
									type=
									"submit"
									value=
									"submit"
									/>
									</form>...
									</html>

#springBind/ <@spring.bind>requires a 'path' argument which consists of the name of your command object (it will be 'command' unless you changed it in your FormController properties) followed by a period and the name of the field on the command object you wish to bind to. Nested fields can be used too such as "command.address.street". The bindmacro assumes the default HTML escaping behavior specified by the ServletContext parameter defaultHtmlEscapein web.xml

The optional form of the macro called #springBindEscaped/ <@spring.bindEscaped>takes a second argument and explicitly specifies whether HTML escaping should be used in the status error messages or values. Set to true or false as required. Additional form handling macros simplify the use of HTML escaping and these macros should be used wherever possible. They are explained in the next section.

Form input generation macros

Additional convenience macros for both languages simplify both binding and form generation (including validation error display). It is never necessary to use these macros to generate form input fields, and they can be mixed and matched with simple HTML or calls direct to the spring bind macros highlighted previously.

The following table of available macros show the VTL and FTL definitions and the parameter list that each takes.

Table 23.1. Table of macro definitions

macro VTL definition FTL definition

message(output a string from a resource bundle based on the code parameter)

#springMessage($code)

<@spring.message code/>

messageText(output a string from a resource bundle based on the code parameter, falling back to the value of the default parameter)

#springMessageText($code $text)

<@spring.messageText code, text/>

url(prefix a relative URL with the application’s context root)

#springUrl($relativeUrl)

<@spring.url relativeUrl/>

formInput(standard input field for gathering user input)

#springFormInput($path $attributes)

<@spring.formInput path, attributes, fieldType/>

formHiddenInput* (hidden input field for submitting non-user input)

#springFormHiddenInput($path $attributes)

<@spring.formHiddenInput path, attributes/>

formPasswordInput* (standard input field for gathering passwords. Note that no value will ever be populated in fields of this type)

#springFormPasswordInput($path $attributes)

<@spring.formPasswordInput path, attributes/>

formTextarea(large text field for gathering long, freeform text input)

#springFormTextarea($path $attributes)

<@spring.formTextarea path, attributes/>

formSingleSelect(drop down box of options allowing a single required value to be selected)

#springFormSingleSelect( $path $options $attributes)

<@spring.formSingleSelect path, options, attributes/>

formMultiSelect(a list box of options allowing the user to select 0 or more values)

#springFormMultiSelect($path $options $attributes)

<@spring.formMultiSelect path, options, attributes/>

formRadioButtons(a set of radio buttons allowing a single selection to be made from the available choices)

#springFormRadioButtons($path $options $separator $attributes)

<@spring.formRadioButtons path, options separator, attributes/>

formCheckboxes(a set of checkboxes allowing 0 or more values to be selected)

#springFormCheckboxes($path $options $separator $attributes)

<@spring.formCheckboxes path, options, separator, attributes/>

formCheckbox(a single checkbox)

#springFormCheckbox($path $attributes)

<@spring.formCheckbox path, attributes/>

showErrors(simplify display of validation errors for the bound field)

#springShowErrors($separator $classOrStyle)

<@spring.showErrors separator, classOrStyle/>

  • In FTL (FreeMarker), these two macros are not actually required as you can use the normal formInputmacro, specifying ' hidden’ or ' `password’ as the value for the `fieldTypeparameter.

The parameters to any of the above macros have consistent meanings:

  • path: the name of the field to bind to (ie "command.name")
  • options: a Map of all the available values that can be selected from in the input field. The keys to the map represent the values that will be POSTed back from the form and bound to the command object. Map objects stored against the keys are the labels displayed on the form to the user and may be different from the corresponding values posted back by the form. Usually such a map is supplied as reference data by the controller. Any Map implementation can be used depending on required behavior. For strictly sorted maps, a SortedMapsuch as a TreeMapwith a suitable Comparator may be used and for arbitrary Maps that should return values in insertion order, use a LinkedHashMapor a LinkedMapfrom commons-collections.
  • separator: where multiple options are available as discreet elements (radio buttons or checkboxes), the sequence of characters used to separate each one in the list (ie "<br>").
  • attributes: an additional string of arbitrary tags or text to be included within the HTML tag itself. This string is echoed literally by the macro. For example, in a textarea field you may supply attributes as 'rows="5" cols="60"' or you could pass style information such as 'style="border:1px solid silver"'.
  • classOrStyle: for the showErrors macro, the name of the CSS class that the span tag wrapping each error will use. If no information is supplied (or the value is empty) then the errors will be wrapped in <b></b> tags.

Examples of the macros are outlined below some in FTL and some in VTL. Where usage differences exist between the two languages, they are explained in the notes.

Input Fields
										<!-- the Name field example from above using form macros in VTL -->... Name: #springFormInput("command.name" "")
										<br>#springShowErrors("
										<br>" "")
										<br>

The formInput macro takes the path parameter (command.name) and an additional attributes parameter which is empty in the example above. The macro, along with all other form generation macros, performs an implicit spring bind on the path parameter. The binding remains valid until a new bind occurs so the showErrors macro doesn’t need to pass the path parameter again - it simply operates on whichever field a bind was last created for.

The showErrors macro takes a separator parameter (the characters that will be used to separate multiple errors on a given field) and also accepts a second parameter, this time a class name or style attribute. Note that FreeMarker is able to specify default values for the attributes parameter, unlike Velocity, and the two macro calls above could be expressed as follows in FTL:

										<@spring.formInput
										"command.name"/>
										<@spring.showErrors
										"<br>"/>

Output is shown below of the form fragment generating the name field, and displaying a validation error after the form was submitted with no value in the field. Validation occurs through Spring’s Validation framework.

The generated HTML looks like this:

Name: <input type="text" name="name" value=""> <br> <b>required</b> <br> <br>

The formTextarea macro works the same way as the formInput macro and accepts the same parameter list. Commonly, the second parameter (attributes) will be used to pass style information or rows and cols attributes for the textarea.

Selection Fields

Four selection field macros can be used to generate common UI value selection inputs in your HTML forms.

  • formSingleSelect
  • formMultiSelect
  • formRadioButtons
  • formCheckboxes

Each of the four macros accepts a Map of options containing the value for the form field, and the label corresponding to that value. The value and the label can be the same.

An example of radio buttons in FTL is below. The form backing object specifies a default value of 'London' for this field and so no validation is necessary. When the form is rendered, the entire list of cities to choose from is supplied as reference data in the model under the name 'cityMap'.

... Town: <@spring.formRadioButtons "command.address.town", cityMap, ""/><br><br>

This renders a line of radio buttons, one for each value in cityMapusing the separator "". No additional attributes are supplied (the last parameter to the macro is missing). The cityMap uses the same String for each key-value pair in the map. The map’s keys are what the form actually submits as POSTed request parameters, map values are the labels that the user sees. In the example above, given a list of three well known cities and a default value in the form backing object, the HTML would be

Town: <input type="radio" name="address.town" value="London">London</input> <input type="radio" name="address.town" value="Paris" checked="checked">Paris</input> <input type="radio" name="address.town" value="New York">New York</input>

If your application expects to handle cities by internal codes for example, the map of codes would be created with suitable keys like the example below.

										protectedMap referenceData(HttpServletRequest request)
										throwsException { Map cityMap =
										newLinkedHashMap(); cityMap.put(
										"LDN",
										"London"); cityMap.put(
										"PRS",
										"Paris"); cityMap.put(
										"NYC",
										"New York"); Map m =
										newHashMap(); m.put(
										"cityMap", cityMap);
										returnm; }

The code would now produce output where the radio values are the relevant codes but the user still sees the more user friendly city names.

Town: <input type="radio" name="address.town" value="LDN">London</input> <input type="radio" name="address.town" value="PRS" checked="checked">Paris</input> <input type="radio" name="address.town" value="NYC">New York</input>

HTML escaping and XHTML compliance

Default usage of the form macros above will result in HTML tags that are HTML 4.01 compliant and that use the default value for HTML escaping defined in your web.xml as used by Spring’s bind support. In order to make the tags XHTML compliant or to override the default HTML escaping value, you can specify two variables in your template (or in your model where they will be visible to your templates). The advantage of specifying them in the templates is that they can be changed to different values later in the template processing to provide different behavior for different fields in your form.

To switch to XHTML compliance for your tags, specify a value of 'true' for a model/context variable named xhtmlCompliant:

									# for Velocity.. #set($springXhtmlCompliant = true) <-- for FreeMarker --> <#assign xhtmlCompliant = true in spring>

Any tags generated by the Spring macros will now be XHTML compliant after processing this directive.

In similar fashion, HTML escaping can be specified per field:

									<#--
									until
									this
									point,
									default
									HTML
									escaping
									is
									used
									-->
									<#assign
									htmlEscape=
									true
									in
									spring>
									<#--
									next
									field
									will
									use
									HTML
									escaping
									-->
									<@spring.formInput
									"command.name"/>
									<#assign
									htmlEscape=
									false
									in
									spring>
									<#--
									all
									future
									fields
									will
									be
									bound
									with
									HTML
									escaping
									off
									-->

23.5 JSP & JSTL

Spring provides a couple of out-of-the-box solutions for JSP and JSTL views. Using JSP or JSTL is done using a normal view resolver defined in the WebApplicationContext. Furthermore, of course you need to write some JSPs that will actually render the view.

[Note] Note

Setting up your application to use JSTL is a common source of error, mainly caused by confusion over the different servlet spec., JSP and JSTL version numbers, what they mean and how to declare the taglibs correctly. The article How to Reference and Use JSTL in your Web Applicationprovides a useful guide to the common pitfalls and how to avoid them. Note that as of Spring 3.0, the minimum supported servlet version is 2.4 (JSP 2.0 and JSTL 1.1), which reduces the scope for confusion somewhat.

23.5.1 View resolvers

Just as with any other view technology you’re integrating with Spring, for JSPs you’ll need a view resolver that will resolve your views. The most commonly used view resolvers when developing with JSPs are the InternalResourceViewResolverand the ResourceBundleViewResolver. Both are declared in the WebApplicationContext:

								<!-- the ResourceBundleViewResolver -->
								<bean
								id=
								"viewResolver"
								class=
								"org.springframework.web.servlet.view.ResourceBundleViewResolver"
								>
								<property
								name=
								"basename"
								value=
								"views"
								/>
								</bean># And a sample properties file is uses (views.properties in WEB-INF/classes): welcome.(class)=org.springframework.web.servlet.view.JstlView welcome.url=/WEB-INF/jsp/welcome.jsp productList.(class)=org.springframework.web.servlet.view.JstlView productList.url=/WEB-INF/jsp/productlist.jsp

As you can see, the ResourceBundleViewResolverneeds a properties file defining the view names mapped to 1) a class and 2) a URL. With a ResourceBundleViewResolveryou can mix different types of views using only one resolver.

								<bean
								id=
								"viewResolver"
								class=
								"org.springframework.web.servlet.view.InternalResourceViewResolver"
								>
								<property
								name=
								"viewClass"
								value=
								"org.springframework.web.servlet.view.JstlView"
								/>
								<property
								name=
								"prefix"
								value=
								"/WEB-INF/jsp/"
								/>
								<property
								name=
								"suffix"
								value=
								".jsp"
								/>
								</bean>

The InternalResourceBundleViewResolvercan be configured for using JSPs as described above. As a best practice, we strongly encourage placing your JSP files in a directory under the 'WEB-INF'directory, so there can be no direct access by clients.

23.5.2 'Plain-old' JSPs versus JSTL

When using the Java Standard Tag Library you must use a special view class, the JstlView, as JSTL needs some preparation before things such as the I18N features will work.

23.5.3 Additional tags facilitating development

Spring provides data binding of request parameters to command objects as described in earlier chapters. To facilitate the development of JSP pages in combination with those data binding features, Spring provides a few tags that make things even easier. All Spring tags have HTML escapingfeatures to enable or disable escaping of characters.

The tag library descriptor (TLD) is included in the spring-webmvc.jar. Further information about the individual tags can be found in the appendix entitled ???.

23.5.4 Using Spring’s form tag library

As of version 2.0, Spring provides a comprehensive set of data binding-aware tags for handling form elements when using JSP and Spring Web MVC. Each tag provides support for the set of attributes of its corresponding HTML tag counterpart, making the tags familiar and intuitive to use. The tag-generated HTML is HTML 4.01/XHTML 1.0 compliant.

Unlike other form/input tag libraries, Spring’s form tag library is integrated with Spring Web MVC, giving the tags access to the command object and reference data your controller deals with. As you will see in the following examples, the form tags make JSPs easier to develop, read and maintain.

Let’s go through the form tags and look at an example of how each tag is used. We have included generated HTML snippets where certain tags require further commentary.

Configuration

The form tag library comes bundled in spring-webmvc.jar. The library descriptor is called spring-form.tld.

To use the tags from this library, add the following directive to the top of your JSP page:

									<%@
									taglib
									prefix=
									"form"
									uri=
									"http://www.springframework.org/tags/form"
									%>

where formis the tag name prefix you want to use for the tags from this library.

The form tag

This tag renders an HTML 'form' tag and exposes a binding path to inner tags for binding. It puts the command object in the PageContextso that the command object can be accessed by inner tags. All the other tags in this library are nested tags of the formtag.

Let’s assume we have a domain object called User. It is a JavaBean with properties such as firstNameand lastName. We will use it as the form backing object of our form controller which returns form.jsp. Below is an example of what form.jspwould look like:

									<form:form>
									<table>
									<tr>
									<td>First Name:
									</td>
									<td>
									<form:input
									path=
									"firstName"
									/>
									</td>
									</tr>
									<tr>
									<td>Last Name:
									</td>
									<td>
									<form:input
									path=
									"lastName"
									/>
									</td>
									</tr>
									<tr>
									<td
									colspan=
									"2"
									>
									<input
									type=
									"submit"
									value=
									"Save Changes"
									/>
									</td>
									</tr>
									</table>
									</form:form>

The firstNameand lastNamevalues are retrieved from the command object placed in the PageContextby the page controller. Keep reading to see more complex examples of how inner tags are used with the formtag.

The generated HTML looks like a standard form:

									<form
									method=
									"POST"
									>
									<table>
									<tr>
									<td>First Name:
									</td>
									<td>
									<input
									name=
									"firstName"
									type=
									"text"
									value=
									"Harry"
									/>
									</td>
									</tr>
									<tr>
									<td>Last Name:
									</td>
									<td>
									<input
									name=
									"lastName"
									type=
									"text"
									value=
									"Potter"
									/>
									</td>
									</tr>
									<tr>
									<td
									colspan=
									"2"
									>
									<input
									type=
									"submit"
									value=
									"Save Changes"
									/>
									</td>
									</tr>
									</table>
									</form>

The preceding JSP assumes that the variable name of the form backing object is 'command'. If you have put the form backing object into the model under another name (definitely a best practice), then you can bind the form to the named variable like so:

									<form:form
									modelAttribute=
									"user"
									>
									<table>
									<tr>
									<td>First Name:
									</td>
									<td>
									<form:input
									path=
									"firstName"
									/>
									</td>
									</tr>
									<tr>
									<td>Last Name:
									</td>
									<td>
									<form:input
									path=
									"lastName"
									/>
									</td>
									</tr>
									<tr>
									<td
									colspan=
									"2"
									>
									<input
									type=
									"submit"
									value=
									"Save Changes"
									/>
									</td>
									</tr>
									</table>
									</form:form>

The input tag

This tag renders an HTML 'input' tag using the bound value and type='text' by default. For an example of this tag, see the section called “The form tag”. Starting with Spring 3.1 you can use other types such HTML5-specific types like 'email', 'tel', 'date', and others.

The checkbox tag

This tag renders an HTML 'input' tag with type 'checkbox'.

Let’s assume our Userhas preferences such as newsletter subscription and a list of hobbies. Below is an example of the Preferencesclass:

									public
									classPreferences {
									private
									booleanreceiveNewsletter;
									privateString[] interests;
									privateString favouriteWord;
									public
									booleanisReceiveNewsletter() {
									returnreceiveNewsletter; }
									public
									voidsetReceiveNewsletter(
									booleanreceiveNewsletter) {
									this.receiveNewsletter = receiveNewsletter; }
									publicString[] getInterests() {
									returninterests; }
									public
									voidsetInterests(String[] interests) {
									this.interests = interests; }
									publicString getFavouriteWord() {
									returnfavouriteWord; }
									public
									voidsetFavouriteWord(String favouriteWord) {
									this.favouriteWord = favouriteWord; } }

The form.jspwould look like:

									<form:form>
									<table>
									<tr>
									<td>Subscribe to newsletter?:
									</td>
									<%--
									Approach
									1:
									Property
									is
									of
									type
									java.lang.Boolean
									--%>
									<td><form:checkbox
									path=
									"preferences.receiveNewsletter"
									/>
									</td>
									</tr>
									<tr>
									<td>Interests:
									</td>
									<%--
									Approach
									2:
									Property
									is
									of
									an
									array
									or
									of
									type
									java.util.Collection
									--%>
									<td>
									Quidditch:
									<form:checkbox
									path=
									"preferences.interests"
									value=
									"Quidditch"
									/>Herbology:
									<form:checkbox
									path=
									"preferences.interests"
									value=
									"Herbology"
									/>Defence Against the Dark Arts:
									<form:checkbox
									path=
									"preferences.interests"
									value=
									"Defence Against the Dark Arts"
									/>
									</td>
									</tr>
									<tr>
									<td>Favourite Word:
									</td>
									<%--
									Approach
									3:
									Property
									is
									of
									type
									java.lang.Object
									--%>
									<td>
									Magic:
									<form:checkbox
									path=
									"preferences.favouriteWord"
									value=
									"Magic"
									/>
									</td>
									</tr>
									</table>
									</form:form>

There are 3 approaches to the checkboxtag which should meet all your checkbox needs.

  • Approach One - When the bound value is of type java.lang.Boolean, the input(checkbox)is marked as 'checked' if the bound value is true. The valueattribute corresponds to the resolved value of the setValue(Object)value property.
  • Approach Two - When the bound value is of type arrayor java.util.Collection, the input(checkbox)is marked as 'checked' if the configured setValue(Object)value is present in the bound Collection.
  • Approach Three - For any other bound value type, the input(checkbox)is marked as 'checked' if the configured setValue(Object)is equal to the bound value.

Note that regardless of the approach, the same HTML structure is generated. Below is an HTML snippet of some checkboxes:

									<tr>
									<td>Interests:
									</td>
									<td>Quidditch:
									<input
									name=
									"preferences.interests"
									type=
									"checkbox"
									value=
									"Quidditch"
									/>
									<input
									type=
									"hidden"
									value=
									"1"
									name=
									"_preferences.interests"
									/>Herbology:
									<input
									name=
									"preferences.interests"
									type=
									"checkbox"
									value=
									"Herbology"
									/>
									<input
									type=
									"hidden"
									value=
									"1"
									name=
									"_preferences.interests"
									/>Defence Against the Dark Arts:
									<input
									name=
									"preferences.interests"
									type=
									"checkbox"
									value=
									"Defence Against the Dark Arts"
									/>
									<input
									type=
									"hidden"
									value=
									"1"
									name=
									"_preferences.interests"
									/>
									</td>
									</tr>

What you might not expect to see is the additional hidden field after each checkbox. When a checkbox in an HTML page is notchecked, its value will not be sent to the server as part of the HTTP request parameters once the form is submitted, so we need a workaround for this quirk in HTML in order for Spring form data binding to work. The checkboxtag follows the existing Spring convention of including a hidden parameter prefixed by an underscore ("_") for each checkbox. By doing this, you are effectively telling Spring that " the checkbox was visible in the form and I want my object to which the form data will be bound to reflect the state of the checkbox no matter what".

The checkboxes tag

This tag renders multiple HTML 'input' tags with type 'checkbox'.

Building on the example from the previous checkboxtag section. Sometimes you prefer not to have to list all the possible hobbies in your JSP page. You would rather provide a list at runtime of the available options and pass that in to the tag. That is the purpose of the checkboxestag. You pass in an Array, a Listor a Mapcontaining the available options in the "items" property. Typically the bound property is a collection so it can hold multiple values selected by the user. Below is an example of the JSP using this tag:

									<form:form>
									<table>
									<tr>
									<td>Interests:
									</td>
									<td>
									<%--
									Property
									is
									of
									an
									array
									or
									of
									type
									java.util.Collection
									--%>
									<form:checkboxes
									path=
									"preferences.interests"
									items=
									"${interestList}"
									/>
									</td>
									</tr>
									</table>
									</form:form>

This example assumes that the "interestList" is a Listavailable as a model attribute containing strings of the values to be selected from. In the case where you use a Map, the map entry key will be used as the value and the map entry’s value will be used as the label to be displayed. You can also use a custom object where you can provide the property names for the value using "itemValue" and the label using "itemLabel".

The radiobutton tag

This tag renders an HTML 'input' tag with type 'radio'.

A typical usage pattern will involve multiple tag instances bound to the same property but with different values.

									<tr>
									<td>Sex:
									</td>
									<td>Male:
									<form:radiobutton
									path=
									"sex"
									value=
									"M"
									/>
									<br/>Female:
									<form:radiobutton
									path=
									"sex"
									value=
									"F"
									/>
									</td>
									</tr>

The radiobuttons tag

This tag renders multiple HTML 'input' tags with type 'radio'.

Just like the checkboxestag above, you might want to pass in the available options as a runtime variable. For this usage you would use the radiobuttonstag. You pass in an Array, a Listor a Mapcontaining the available options in the "items" property. In the case where you use a Map, the map entry key will be used as the value and the map entry’s value will be used as the label to be displayed. You can also use a custom object where you can provide the property names for the value using "itemValue" and the label using "itemLabel".

									<tr>
									<td>Sex:
									</td>
									<td>
									<form:radiobuttons
									path=
									"sex"
									items=
									"${sexOptions}"
									/>
									</td>
									</tr>

The password tag

This tag renders an HTML 'input' tag with type 'password' using the bound value.

									<tr>
									<td>Password:
									</td>
									<td>
									<form:password
									path=
									"password"
									/>
									</td>
									</tr>

Please note that by default, the password value is notshown. If you do want the password value to be shown, then set the value of the 'showPassword'attribute to true, like so.

									<tr>
									<td>Password:
									</td>
									<td>
									<form:password
									path=
									"password"
									value=
									"^76525bvHGq"
									showPassword=
									"true"
									/>
									</td>
									</tr>

The select tag

This tag renders an HTML 'select' element. It supports data binding to the selected option as well as the use of nested optionand optionstags.

Let’s assume a Userhas a list of skills.

									<tr>
									<td>Skills:
									</td>
									<td>
									<form:select
									path=
									"skills"
									items=
									"${skills}"
									/>
									</td>
									</tr>

If the User’sskill were in Herbology, the HTML source of the 'Skills' row would look like:

									<tr>
									<td>Skills:
									</td>
									<td>
									<select
									name=
									"skills"
									multiple=
									"true"
									>
									<option
									value=
									"Potions"
									>Potions
									</option>
									<option
									value=
									"Herbology"
									selected=
									"selected"
									>Herbology
									</option>
									<option
									value=
									"Quidditch"
									>Quidditch
									</option>
									</select>
									</td>
									</tr>

The option tag

This tag renders an HTML 'option'. It sets 'selected' as appropriate based on the bound value.

									<tr>
									<td>House:
									</td>
									<td>
									<form:select
									path=
									"house"
									>
									<form:option
									value=
									"Gryffindor"
									/>
									<form:option
									value=
									"Hufflepuff"
									/>
									<form:option
									value=
									"Ravenclaw"
									/>
									<form:option
									value=
									"Slytherin"
									/>
									</form:select>
									</td>
									</tr>

If the User’shouse was in Gryffindor, the HTML source of the 'House' row would look like:

									<tr>
									<td>House:
									</td>
									<td>
									<select
									name=
									"house"
									>
									<option
									value=
									"Gryffindor"
									selected=
									"selected"
									>Gryffindor
									</option>
									<option
									value=
									"Hufflepuff"
									>Hufflepuff
									</option>
									<option
									value=
									"Ravenclaw"
									>Ravenclaw
									</option>
									<option
									value=
									"Slytherin"
									>Slytherin
									</option>
									</select>
									</td>
									</tr>

The options tag

This tag renders a list of HTML 'option' tags. It sets the 'selected' attribute as appropriate based on the bound value.

									<tr>
									<td>Country:
									</td>
									<td>
									<form:select
									path=
									"country"
									>
									<form:option
									value=
									"-"
									label=
									"--Please Select"
									/>
									<form:options
									items=
									"${countryList}"
									itemValue=
									"code"
									itemLabel=
									"name"
									/>
									</form:select>
									</td>
									</tr>

If the Userlived in the UK, the HTML source of the 'Country' row would look like:

									<tr>
									<td>Country:
									</td>
									<td>
									<select
									name=
									"country"
									>
									<option
									value=
									"-"
									>--Please Select
									</option>
									<option
									value=
									"AT"
									>Austria
									</option>
									<option
									value=
									"UK"
									selected=
									"selected"
									>United Kingdom
									</option>
									<option
									value=
									"US"
									>United States
									</option>
									</select>
									</td>
									</tr>

As the example shows, the combined usage of an optiontag with the optionstag generates the same standard HTML, but allows you to explicitly specify a value in the JSP that is for display only (where it belongs) such as the default string in the example: "-- Please Select".

The itemsattribute is typically populated with a collection or array of item objects. itemValueand itemLabelsimply refer to bean properties of those item objects, if specified; otherwise, the item objects themselves will be stringified. Alternatively, you may specify a Mapof items, in which case the map keys are interpreted as option values and the map values correspond to option labels. If itemValueand/or itemLabelhappen to be specified as well, the item value property will apply to the map key and the item label property will apply to the map value.

The textarea tag

This tag renders an HTML 'textarea'.

									<tr>
									<td>Notes:
									</td>
									<td>
									<form:textarea
									path=
									"notes"
									rows=
									"3"
									cols=
									"20"
									/>
									</td>
									<td>
									<form:errors
									path=
									"notes"
									/>
									</td>
									</tr>

The hidden tag

This tag renders an HTML 'input' tag with type 'hidden' using the bound value. To submit an unbound hidden value, use the HTML inputtag with type 'hidden'.

									<form:hidden
									path=
									"house"
									/>

If we choose to submit the 'house' value as a hidden one, the HTML would look like:

									<input
									name=
									"house"
									type=
									"hidden"
									value=
									"Gryffindor"
									/>

The errors tag

This tag renders field errors in an HTML 'span' tag. It provides access to the errors created in your controller or those that were created by any validators associated with your controller.

Let’s assume we want to display all error messages for the firstNameand lastNamefields once we submit the form. We have a validator for instances of the Userclass called UserValidator.

									public
									classUserValidator
									implementsValidator {
									public
									booleansupports(Class candidate) {
									returnUser.
									class.isAssignableFrom(candidate); }
									public
									voidvalidate(Object obj, Errors errors) { ValidationUtils.rejectIfEmptyOrWhitespace(errors,
									"firstName",
									"required",
									"Field is required."); ValidationUtils.rejectIfEmptyOrWhitespace(errors,
									"lastName",
									"required",
									"Field is required."); } }

The form.jspwould look like:

									<form:form>
									<table>
									<tr>
									<td>First Name:
									</td>
									<td>
									<form:input
									path=
									"firstName"
									/>
									</td>
									<%--
									Show
									errors
									for
									firstName
									field
									--%>
									<td><form:errors
									path=
									"firstName"
									/>
									</td>
									</tr>
									<tr>
									<td>Last Name:
									</td>
									<td>
									<form:input
									path=
									"lastName"
									/>
									</td>
									<%--
									Show
									errors
									for
									lastName
									field
									--%>
									<td><form:errors
									path=
									"lastName"
									/>
									</td>
									</tr>
									<tr>
									<td
									colspan=
									"3"
									>
									<input
									type=
									"submit"
									value=
									"Save Changes"
									/>
									</td>
									</tr>
									</table>
									</form:form>

If we submit a form with empty values in the firstNameand lastNamefields, this is what the HTML would look like:

									<form
									method=
									"POST"
									>
									<table>
									<tr>
									<td>First Name:
									</td>
									<td>
									<input
									name=
									"firstName"
									type=
									"text"
									value=
									""
									/>
									</td>
									<%--
									Associated
									errors
									to
									firstName
									field
									displayed
									--%>
									<td><span
									name=
									"firstName.errors"
									>Field is required.
									</span>
									</td>
									</tr>
									<tr>
									<td>Last Name:
									</td>
									<td>
									<input
									name=
									"lastName"
									type=
									"text"
									value=
									""
									/>
									</td>
									<%--
									Associated
									errors
									to
									lastName
									field
									displayed
									--%>
									<td><span
									name=
									"lastName.errors"
									>Field is required.
									</span>
									</td>
									</tr>
									<tr>
									<td
									colspan=
									"3"
									>
									<input
									type=
									"submit"
									value=
									"Save Changes"
									/>
									</td>
									</tr>
									</table>
									</form>

What if we want to display the entire list of errors for a given page? The example below shows that the errorstag also supports some basic wildcarding functionality.

  • path="*"- displays all errors
  • path="lastName"- displays all errors associated with the lastNamefield
  • if pathis omitted - object errors only are displayed

The example below will display a list of errors at the top of the page, followed by field-specific errors next to the fields:

									<form:form>
									<form:errors
									path=
									"*"
									cssClass=
									"errorBox"
									/>
									<table>
									<tr>
									<td>First Name:
									</td>
									<td>
									<form:input
									path=
									"firstName"
									/>
									</td>
									<td>
									<form:errors
									path=
									"firstName"
									/>
									</td>
									</tr>
									<tr>
									<td>Last Name:
									</td>
									<td>
									<form:input
									path=
									"lastName"
									/>
									</td>
									<td>
									<form:errors
									path=
									"lastName"
									/>
									</td>
									</tr>
									<tr>
									<td
									colspan=
									"3"
									>
									<input
									type=
									"submit"
									value=
									"Save Changes"
									/>
									</td>
									</tr>
									</table>
									</form:form>

The HTML would look like:

									<form
									method=
									"POST"
									>
									<span
									name=
									"*.errors"
									class=
									"errorBox"
									>Field is required.
									<br/>Field is required.
									</span>
									<table>
									<tr>
									<td>First Name:
									</td>
									<td>
									<input
									name=
									"firstName"
									type=
									"text"
									value=
									""
									/>
									</td>
									<td>
									<span
									name=
									"firstName.errors"
									>Field is required.
									</span>
									</td>
									</tr>
									<tr>
									<td>Last Name:
									</td>
									<td>
									<input
									name=
									"lastName"
									type=
									"text"
									value=
									""
									/>
									</td>
									<td>
									<span
									name=
									"lastName.errors"
									>Field is required.
									</span>
									</td>
									</tr>
									<tr>
									<td
									colspan=
									"3"
									>
									<input
									type=
									"submit"
									value=
									"Save Changes"
									/>
									</td>
									</tr>
									</table>
									</form>

HTTP Method Conversion

A key principle of REST is the use of the Uniform Interface. This means that all resources (URLs) can be manipulated using the same four HTTP methods: GET, PUT, POST, and DELETE. For each method, the HTTP specification defines the exact semantics. For instance, a GET should always be a safe operation, meaning that is has no side effects, and a PUT or DELETE should be idempotent, meaning that you can repeat these operations over and over again, but the end result should be the same. While HTTP defines these four methods, HTML only supports two: GET and POST. Fortunately, there are two possible workarounds: you can either use JavaScript to do your PUT or DELETE, or simply do a POST with the 'real' method as an additional parameter (modeled as a hidden input field in an HTML form). This latter trick is what Spring’s HiddenHttpMethodFilterdoes. This filter is a plain Servlet Filter and therefore it can be used in combination with any web framework (not just Spring MVC). Simply add this filter to your web.xml, and a POST with a hidden _method parameter will be converted into the corresponding HTTP method request.

To support HTTP method conversion the Spring MVC form tag was updated to support setting the HTTP method. For example, the following snippet taken from the updated Petclinic sample

									<form:form
									method=
									"delete"
									>
									<p
									class=
									"submit"
									>
									<input
									type=
									"submit"
									value=
									"Delete Pet"
									/>
									</p>
									</form:form>

This will actually perform an HTTP POST, with the 'real' DELETE method hidden behind a request parameter, to be picked up by the HiddenHttpMethodFilter, as defined in web.xml:

<filter> <filter-name>httpMethodFilter</filter-name> <filter-
									class>org.springframework.web.filter.HiddenHttpMethodFilter</filter-
									class> </filter> <filter-mapping> <filter-name>httpMethodFilter</filter-name> <servlet-name>petclinic</servlet-name> </filter-mapping>

The corresponding @Controllermethod is shown below:

									
										@RequestMapping(method = RequestMethod.DELETE)
									publicString deletePet(
									
										@PathVariable
									intownerId,
									
										@PathVariable
									intpetId) {
									this.clinic.deletePet(petId);
									return
									"redirect:/owners/"+ ownerId; }

HTML5 Tags

Starting with Spring 3, the Spring form tag library allows entering dynamic attributes, which means you can enter any HTML5 specific attributes.

In Spring 3.1, the form input tag supports entering a type attribute other than 'text'. This is intended to allow rendering new HTML5 specific input types such as 'email', 'date', 'range', and others. Note that entering type='text' is not required since 'text' is the default type.

23.6 Script templates

It is possible to integrate any templating library running on top of a JSR-223 script engine in web applications using Spring. The following describes in a broad way how to do this. The script engine must implement both ScriptEngineand Invocableinterfaces.

It has been tested with:

23.6.1 Dependencies

To be able to use script templates integration, you need to have available in your classpath the script engine:

  • NashornJavascript engine is provided builtin with Java 8+. Using the latest update release available is highly recommended.
  • RhinoJavascript engine is provided builtin with Java 6 and Java 7. Please notice that using Rhino is not recommended since it does not support running most template engines.
  • JRubydependency should be added in order to get Ruby support.
  • Jythondependency should be added in order to get Python support.

You should also need to add dependencies for your script based template engine. For example, for Javascript you can use WebJarsto add Maven/Gradle dependencies in order to make your javascript libraries available in the classpath.

23.6.2 How to integrate script based templating

To be able to use script templates, you have to configure it in order to specify various parameters like the script engine to use, the script files to load and what function should be called to render the templates. This is done thanks to a ScriptTemplateConfigurerbean and optional script files.

For example, in order to render Mustache templates thanks to the Nashorn Javascript engine provided with Java 8+, you should declare the following configuration:

								
									@Configuration
								
									@EnableWebMvc
								public
								classMustacheConfig
								extendsWebMvcConfigurerAdapter {
								
									@Override
								public
								voidconfigureViewResolvers(ViewResolverRegistry registry) { registry.scriptTemplate(); }
								
									@Bean
								publicScriptTemplateConfigurer configurer() { ScriptTemplateConfigurer configurer =
								newScriptTemplateConfigurer(); configurer.setEngineName(
								"nashorn"); configurer.setScripts(
								"mustache.js"); configurer.setRenderObject(
								"Mustache"); configurer.setRenderFunction(
								"render");
								returnconfigurer; } }

The XML counterpart using MVC namespace is:

								<mvc:annotation-driven/>
								<mvc:view-resolvers>
								<mvc:script-template/>
								</mvc:view-resolvers>
								<mvc:script-template-configurer
								engine-name=
								"nashorn"
								render-object=
								"Mustache"
								render-function=
								"render"
								>
								<mvc:script
								location=
								"mustache.js"
								/>
								</mvc:script-template-configurer>

The controller is exactly what you should expect:

								
									@Controller
								public
								classSampleController {
								
									@RequestMapping
								publicModelAndView test() { ModelAndView mav =
								newModelAndView(); mav.addObject(
								"title",
								"Sample title").addObject(
								"body",
								"Sample body"); mav.setViewName(
								"template.html");
								returnmav; } }

And the Mustache template is:

<html> <head> <title>{{title}}</title> </head> <body> <p>{{body}}</p> </body> </html>

The render function is called with the following parameters:

  • String template: the template content
  • Map model: the view model
  • String url: the template url (since 4.2.2)

Mustache.render()is natively compatible with this signature, so you can call it directly.

If your templating technology requires some customization, you may provide a script that implements a custom render function. For example, Handlerbarsneeds to compile templates before using them, and requires a polyfillin order to emulate some browser facilities not available in the server-side script engine.

								
									@Configuration
								
									@EnableWebMvc
								public
								classMustacheConfig
								extendsWebMvcConfigurerAdapter {
								
									@Override
								public
								voidconfigureViewResolvers(ViewResolverRegistry registry) { registry.scriptTemplate(); }
								
									@Bean
								publicScriptTemplateConfigurer configurer() { ScriptTemplateConfigurer configurer =
								newScriptTemplateConfigurer(); configurer.setEngineName(
								"nashorn"); configurer.setScripts(
								"polyfill.js",
								"handlebars.js",
								"render.js"); configurer.setRenderFunction(
								"render"); configurer.setSharedEngine(false);
								returnconfigurer; } }
[Note] Note

Setting the sharedEngineproperty to falseis required when using non thread-safe script engines with templating libraries not designed for concurrency, like Handlebars or React running on Nashorn for example. In that case, Java 8u60 or greater is required due to this bug.

polyfill.jsonly defines the windowobject needed by Handlebars to run properly:

								varwindow = {};

This basic render.jsimplementation compiles the template before using it. A production ready implementation should also store and reused cached templates / pre-compiled templates. This can be done on the script side, as well as any customization you need (managing template engine configuration for example).

								functionrender(template, model) {
								varcompiledTemplate = Handlebars.compile(template);
								returncompiledTemplate(model); }

Check out Spring script templates unit tests ( java, resources) for more configuration examples.

23.7 XML Marshalling View

The MarshallingViewuses an XML Marshallerdefined in the org.springframework.oxmpackage to render the response content as XML. The object to be marshalled can be set explicitly using MarhsallingView’s `modelKeybean property. Alternatively, the view will iterate over all model properties and marshal the first type that is supported by the Marshaller. For more information on the functionality in the org.springframework.oxmpackage refer to the chapter Marshalling XML using O/X Mappers.

23.8 Tiles

It is possible to integrate Tiles - just as any other view technology - in web applications using Spring. The following describes in a broad way how to do this.

[Note] Note

This section focuses on Spring’s support for Tiles v3 in the org.springframework.web.servlet.view.tiles3package.

23.8.1 Dependencies

To be able to use Tiles, you have to add a dependency on Tiles version 3.0.1 or higher and its transitive dependenciesto your project.

23.8.2 How to integrate Tiles

To be able to use Tiles, you have to configure it using files containing definitions (for basic information on definitions and other Tiles concepts, please have a look at http://tiles.apache.org). In Spring this is done using the TilesConfigurer. Have a look at the following piece of example ApplicationContext configuration:

								<bean
								id=
								"tilesConfigurer"
								class=
								"org.springframework.web.servlet.view.tiles3.TilesConfigurer"
								>
								<property
								name=
								"definitions"
								>
								<list>
								<value>/WEB-INF/defs/general.xml
								</value>
								<value>/WEB-INF/defs/widgets.xml
								</value>
								<value>/WEB-INF/defs/administrator.xml
								</value>
								<value>/WEB-INF/defs/customer.xml
								</value>
								<value>/WEB-INF/defs/templates.xml
								</value>
								</list>
								</property>
								</bean>

As you can see, there are five files containing definitions, which are all located in the 'WEB-INF/defs'directory. At initialization of the WebApplicationContext, the files will be loaded and the definitions factory will be initialized. After that has been done, the Tiles includes in the definition files can be used as views within your Spring web application. To be able to use the views you have to have a ViewResolverjust as with any other view technology used with Spring. Below you can find two possibilities, the UrlBasedViewResolverand the ResourceBundleViewResolver.

You can specify locale specific Tiles definitions by adding an underscore and then the locale. For example:

								<bean
								id=
								"tilesConfigurer"
								class=
								"org.springframework.web.servlet.view.tiles3.TilesConfigurer"
								>
								<property
								name=
								"definitions"
								>
								<list>
								<value>/WEB-INF/defs/tiles.xml
								</value>
								<value>/WEB-INF/defs/tiles_fr_FR.xml
								</value>
								</list>
								</property>
								</bean>

With this configuration, tiles_fr_FR.xmlwill be used for requests with the fr_FRlocale, and tiles.xmlwill be used by default.

[Note] Note

Since underscores are used to indicate locales, it is recommended to avoid using them otherwise in the file names for Tiles definitions.

UrlBasedViewResolver

The UrlBasedViewResolverinstantiates the given viewClassfor each view it has to resolve.

									<bean
									id=
									"viewResolver"
									class=
									"org.springframework.web.servlet.view.UrlBasedViewResolver"
									>
									<property
									name=
									"viewClass"
									value=
									"org.springframework.web.servlet.view.tiles3.TilesView"
									/>
									</bean>

ResourceBundleViewResolver

The ResourceBundleViewResolverhas to be provided with a property file containing viewnames and viewclasses the resolver can use:

									<bean
									id=
									"viewResolver"
									class=
									"org.springframework.web.servlet.view.ResourceBundleViewResolver"
									>
									<property
									name=
									"basename"
									value=
									"views"
									/>
									</bean>
... welcomeView.(
									class)=org.springframework.web.servlet.view.tiles3.TilesView welcomeView.url=welcome (
									thisis the name of a Tiles definition) vetsView.(
									class)=org.springframework.web.servlet.view.tiles3.TilesView vetsView.url=vetsView (again,
									thisis the name of a Tiles definition) findOwnersForm.(
									class)=org.springframework.web.servlet.view.JstlView findOwnersForm.url=/WEB-INF/jsp/findOwners.jsp ...

As you can see, when using the ResourceBundleViewResolver, you can easily mix different view technologies.

Note that the TilesViewclass supports JSTL (the JSP Standard Tag Library) out of the box.

SimpleSpringPreparerFactory and SpringBeanPreparerFactory

As an advanced feature, Spring also supports two special Tiles PreparerFactoryimplementations. Check out the Tiles documentation for details on how to use ViewPreparerreferences in your Tiles definition files.

Specify SimpleSpringPreparerFactoryto autowire ViewPreparer instances based on specified preparer classes, applying Spring’s container callbacks as well as applying configured Spring BeanPostProcessors. If Spring’s context-wide annotation-config has been activated, annotations in ViewPreparer classes will be automatically detected and applied. Note that this expects preparer classesin the Tiles definition files, just like the default PreparerFactorydoes.

Specify SpringBeanPreparerFactoryto operate on specified preparer namesinstead of classes, obtaining the corresponding Spring bean from the DispatcherServlet’s application context. The full bean creation process will be in the control of the Spring application context in this case, allowing for the use of explicit dependency injection configuration, scoped beans etc. Note that you need to define one Spring bean definition per preparer name (as used in your Tiles definitions).

									<bean
									id=
									"tilesConfigurer"
									class=
									"org.springframework.web.servlet.view.tiles3.TilesConfigurer"
									>
									<property
									name=
									"definitions"
									>
									<list>
									<value>/WEB-INF/defs/general.xml
									</value>
									<value>/WEB-INF/defs/widgets.xml
									</value>
									<value>/WEB-INF/defs/administrator.xml
									</value>
									<value>/WEB-INF/defs/customer.xml
									</value>
									<value>/WEB-INF/defs/templates.xml
									</value>
									</list>
									</property>
									<!-- resolving preparer names as Spring bean definition names -->
									<property
									name=
									"preparerFactoryClass"
									value=
									"org.springframework.web.servlet.view.tiles3.SpringBeanPreparerFactory"
									/>
									</bean>

23.9 XSLT

XSLT is a transformation language for XML and is popular as a view technology within web applications. XSLT can be a good choice as a view technology if your application naturally deals with XML, or if your model can easily be converted to XML. The following section shows how to produce an XML document as model data and have it transformed with XSLT in a Spring Web MVC application.

23.9.1 My First Words

This example is a trivial Spring application that creates a list of words in the Controllerand adds them to the model map. The map is returned along with the view name of our XSLT view. See Section 22.3, “Implementing Controllers”for details of Spring Web MVC’s Controllerinterface. The XSLT Controller will turn the list of words into a simple XML document ready for transformation.

Bean definitions

Configuration is standard for a simple Spring application. The MVC configuration has to define a XsltViewResolverbean and regular MVC annotation configuration.

									
										@EnableWebMvc
									
										@ComponentScan
									
										@Configuration
									public
									classWebConfig
									extendsWebMvcConfigurerAdapter {
									
										@Bean
									publicXsltViewResolver xsltViewResolver() { XsltViewResolver viewResolver =
									newXsltViewResolver(); viewResolver.setPrefix(
									"/WEB-INF/xsl/"); viewResolver.setSuffix(
									".xslt");
									returnviewResolver; } }

And we need a Controller that encapsulates our word generation logic.

Standard MVC controller code

The controller logic is encapsulated in a @Controllerclass, with the handler method being defined like so…​

									
										@Controller
									public
									classXsltController {
									
										@RequestMapping("/")
									publicString home(Model model)
									throwsException { Document document = DocumentBuilderFactory.newInstance().newDocumentBuilder().newDocument(); Element root = document.createElement(
									"wordList"); List<String> words = Arrays.asList(
									"Hello",
									"Spring",
									"Framework");
									for(String word : words) { Element wordNode = document.createElement(
									"word"); Text textNode = document.createTextNode(word); wordNode.appendChild(textNode); root.appendChild(wordNode); } model.addAttribute(
									"wordList", root);
									return
									"home"; } }

So far we’ve only created a DOM document and added it to the Model map. Note that you can also load an XML file as a Resourceand use it instead of a custom DOM document.

Of course, there are software packages available that will automatically 'domify' an object graph, but within Spring, you have complete flexibility to create the DOM from your model in any way you choose. This prevents the transformation of XML playing too great a part in the structure of your model data which is a danger when using tools to manage the domification process.

Next, XsltViewResolverwill resolve the "home" XSLT template file and merge the DOM document into it to generate our view.

Document transformation

Finally, the XsltViewResolverwill resolve the "home" XSLT template file and merge the DOM document into it to generate our view. As shown in the XsltViewResolverconfiguration, XSLT templates live in the war file in the 'WEB-INF/xsl'directory and end with a "xslt"file extension.

									<?xml version="1.0" encoding="utf-8"?>
									<xsl:stylesheet
									version=
									"1.0"
									xmlns:xsl=
									"http://www.w3.org/1999/XSL/Transform"
									>
									<xsl:output
									method=
									"html"
									omit-xml-declaration=
									"yes"
									/>
									<xsl:template
									match=
									"/"
									>
									<html>
									<head>
									<title>Hello!
									</title>
									</head>
									<body>
									<h1>My First Words
									</h1>
									<ul>
									<xsl:apply-templates/>
									</ul>
									</body>
									</html>
									</xsl:template>
									<xsl:template
									match=
									"word"
									>
									<li>
									<xsl:value-of
									select=
									"."
									/>
									</li>
									</xsl:template>
									</xsl:stylesheet>

This is rendered as:

<html> <head> <META
									http-equiv=
									"Content-Type"
									content=
									"text/html; charset=UTF-8"> <title>Hello!</title> </head> <body> <h1>My First Words</h1> <ul> <li>Hello</li> <li>Spring</li> <li>Framework</li> </ul> </body> </html>

23.10 Document views (PDF/Excel)

23.10.1 Introduction

Returning an HTML page isn’t always the best way for the user to view the model output, and Spring makes it simple to generate a PDF document or an Excel spreadsheet dynamically from the model data. The document is the view and will be streamed from the server with the correct content type to (hopefully) enable the client PC to run their spreadsheet or PDF viewer application in response.

In order to use Excel views, you need to add the 'poi' library to your classpath, and for PDF generation, the iText library.

23.10.2 Configuration and setup

Document based views are handled in an almost identical fashion to XSLT views, and the following sections build upon the previous one by demonstrating how the same controller used in the XSLT example is invoked to render the same model as both a PDF document and an Excel spreadsheet (which can also be viewed or manipulated in Open Office).

Document view definitions

First, let’s amend the views.properties file (or xml equivalent) and add a simple view definition for both document types. The entire file now looks like this with the XSLT view shown from earlier:

home.(class)=xslt.HomePage home.stylesheetLocation=/WEB-INF/xsl/home.xslt home.root=words xl.(class)=excel.HomePage pdf.(class)=pdf.HomePage

If you want to start with a template spreadsheet or a fillable PDF form to add your model data to, specify the location as the 'url' property in the view definition

Controller code

The controller code we’ll use remains exactly the same from the XSLT example earlier other than to change the name of the view to use. Of course, you could be clever and have this selected based on a URL parameter or some other logic - proof that Spring really is very good at decoupling the views from the controllers!

Subclassing for Excel views

Exactly as we did for the XSLT example, we’ll subclass suitable abstract classes in order to implement custom behavior in generating our output documents. For Excel, this involves writing a subclass of org.springframework.web.servlet.view.document.AbstractExcelView(for Excel files generated by POI) or org.springframework.web.servlet.view.document.AbstractJExcelView(for JExcelApi-generated Excel files) and implementing the buildExcelDocument()method.

Here’s the complete listing for our POI Excel view which displays the word list from the model map in consecutive rows of the first column of a new spreadsheet:

									packageexcel;
									// imports omitted for brevity
									public
									classHomePage
									extendsAbstractExcelView {
									protected
									voidbuildExcelDocument(Map model, HSSFWorkbook wb, HttpServletRequest req, HttpServletResponse resp)
									throwsException { HSSFSheet sheet; HSSFRow sheetRow; HSSFCell cell;
									// Go to the first sheet
									// getSheetAt: only if wb is created from an existing document
									// sheet = wb.getSheetAt(0);sheet = wb.createSheet(
									"Spring"); sheet.setDefaultColumnWidth((
									short)
									12);
									// write a text at A1cell = getCell(sheet,
									0,
									0); setText(cell,
									"Spring-Excel test"); List words = (List) model.get(
									"wordList");
									for(
									inti=
									0; i < words.size(); i++) { cell = getCell(sheet,
									2+i,
									0); setText(cell, (String) words.get(i)); } } }

And the following is a view generating the same Excel file, now using JExcelApi:

									packageexcel;
									// imports omitted for brevity
									public
									classHomePage
									extendsAbstractJExcelView {
									protected
									voidbuildExcelDocument(Map model, WritableWorkbook wb, HttpServletRequest request, HttpServletResponse response)
									throwsException { WritableSheet sheet = wb.createSheet(
									"Spring",
									0); sheet.addCell(
									newLabel(
									0,
									0,
									"Spring-Excel test")); List words = (List) model.get(
									"wordList");
									for(
									inti =
									0; i < words.size(); i++) { sheet.addCell(
									newLabel(
									2+i,
									0, (String) words.get(i))); } } }

Note the differences between the APIs. We’ve found that the JExcelApi is somewhat more intuitive, and furthermore, JExcelApi has slightly better image-handling capabilities. There have been memory problems with large Excel files when using JExcelApi however.

If you now amend the controller such that it returns xlas the name of the view ( return new ModelAndView("xl", map);) and run your application again, you should find that the Excel spreadsheet is created and downloaded automatically when you request the same page as before.

Subclassing for PDF views

The PDF version of the word list is even simpler. This time, the class extends org.springframework.web.servlet.view.document.AbstractPdfViewand implements the buildPdfDocument()method as follows:

									packagepdf;
									// imports omitted for brevity
									public
									classPDFPage
									extendsAbstractPdfView {
									protected
									voidbuildPdfDocument(Map model, Document doc, PdfWriter writer, HttpServletRequest req, HttpServletResponse resp)
									throwsException { List words = (List) model.get(
									"wordList");
									for(
									inti=
									0; i<words.size(); i++) { doc.add(
									newParagraph((String) words.get(i))); } } }

Once again, amend the controller to return the pdfview with return new ModelAndView("pdf", map);, and reload the URL in your application. This time a PDF document should appear listing each of the words in the model map.

23.11 JasperReports

JasperReports ( http://jasperreports.sourceforge.net) is a powerful open-source reporting engine that supports the creation of report designs using an easily understood XML file format. JasperReports is capable of rendering reports in four different formats: CSV, Excel, HTML and PDF.

23.11.1 Dependencies

Your application will need to include the latest release of JasperReports, which at the time of writing was 0.6.1. JasperReports itself depends on the following projects:

  • BeanShell
  • Commons BeanUtils
  • Commons Collections
  • Commons Digester
  • Commons Logging
  • iText
  • POI

JasperReports also requires a JAXP compliant XML parser.

23.11.2 Configuration

To configure JasperReports views in your Spring container configuration you need to define a ViewResolverto map view names to the appropriate view class depending on which format you want your report rendered in.

Configuring the ViewResolver

Typically, you will use the ResourceBundleViewResolverto map view names to view classes and files in a properties file.

									<bean
									id=
									"viewResolver"
									class=
									"org.springframework.web.servlet.view.ResourceBundleViewResolver"
									>
									<property
									name=
									"basename"
									value=
									"views"
									/>
									</bean>

Here we’ve configured an instance of the ResourceBundleViewResolverclass that will look for view mappings in the resource bundle with base name views. (The content of this file is described in the next section.)

Configuring the Views

The Spring Framework contains five different Viewimplementations for JasperReports, four of which correspond to one of the four output formats supported by JasperReports, and one that allows for the format to be determined at runtime:

Table 23.2. JasperReports View classes

Class Name Render Format

JasperReportsCsvView

CSV

JasperReportsHtmlView

HTML

JasperReportsPdfView

PDF

JasperReportsXlsView

Microsoft Excel

JasperReportsMultiFormatView

The view is decided upon at runtime

Mapping one of these classes to a view name and a report file is a matter of adding the appropriate entries in the resource bundle configured in the previous section as shown here:

simpleReport.(class)=org.springframework.web.servlet.view.jasperreports.JasperReportsPdfView simpleReport.url=/WEB-INF/reports/DataSourceReport.jasper

Here you can see that the view with name simpleReportis mapped to the JasperReportsPdfViewclass, causing the output of this report to be rendered in PDF format. The urlproperty of the view is set to the location of the underlying report file.

About Report Files

JasperReports has two distinct types of report file: the design file, which has a .jrxmlextension, and the compiled report file, which has a .jasperextension. Typically, you use the JasperReports Ant task to compile your .jrxmldesign file into a .jasperfile before deploying it into your application. With the Spring Framework you can map either of these files to your report file and the framework will take care of compiling the .jrxmlfile on the fly for you. You should note that after a .jrxmlfile is compiled by the Spring Framework, the compiled report is cached for the lifetime of the application. Thus, to make changes to the file you will need to restart your application.

Using JasperReportsMultiFormatView

The JasperReportsMultiFormatViewallows for the report format to be specified at runtime. The actual rendering of the report is delegated to one of the other JasperReports view classes - the JasperReportsMultiFormatViewclass simply adds a wrapper layer that allows for the exact implementation to be specified at runtime.

The JasperReportsMultiFormatViewclass introduces two concepts: the format key and the discriminator key. The JasperReportsMultiFormatViewclass uses the mapping key to look up the actual view implementation class, and it uses the format key to lookup up the mapping key. From a coding perspective you add an entry to your model with the format key as the key and the mapping key as the value, for example:

									publicModelAndView handleSimpleReportMulti(HttpServletRequest request, HttpServletResponse response)
									throwsException { String uri = request.getRequestURI(); String format = uri.substring(uri.lastIndexOf(
									".") +
									1); Map model = getModel(); model.put(
									"format", format);
									return
									newModelAndView(
									"simpleReportMulti", model); }

In this example, the mapping key is determined from the extension of the request URI and is added to the model under the default format key: format. If you wish to use a different format key then you can configure this using the formatKeyproperty of the JasperReportsMultiFormatViewclass.

By default the following mapping key mappings are configured in JasperReportsMultiFormatView:

Table 23.3. JasperReportsMultiFormatView Default Mapping Key Mappings

Mapping Key View Class

csv

JasperReportsCsvView

html

JasperReportsHtmlView

pdf

JasperReportsPdfView

xls

JasperReportsXlsView

So in the example above a request to URI /foo/myReport.pdf would be mapped to the JasperReportsPdfViewclass. You can override the mapping key to view class mappings using the formatMappingsproperty of JasperReportsMultiFormatView.

23.11.3 Populating the ModelAndView

In order to render your report correctly in the format you have chosen, you must supply Spring with all of the data needed to populate your report. For JasperReports this means you must pass in all report parameters along with the report datasource. Report parameters are simple name/value pairs and can be added to the Mapfor your model as you would add any name/value pair.

When adding the datasource to the model you have two approaches to choose from. The first approach is to add an instance of JRDataSourceor a Collectiontype to the model Mapunder any arbitrary key. Spring will then locate this object in the model and treat it as the report datasource. For example, you may populate your model like so:

								privateMap getModel() { Map model =
								newHashMap(); Collection beanData = getBeanData(); model.put(
								"myBeanData", beanData);
								returnmodel; }

The second approach is to add the instance of JRDataSourceor Collectionunder a specific key and then configure this key using the reportDataKeyproperty of the view class. In both cases Spring will wrap instances of Collectionin a JRBeanCollectionDataSourceinstance. For example:

								privateMap getModel() { Map model =
								newHashMap(); Collection beanData = getBeanData(); Collection someData = getSomeData(); model.put(
								"myBeanData", beanData); model.put(
								"someData", someData);
								returnmodel; }

Here you can see that two Collectioninstances are being added to the model. To ensure that the correct one is used, we simply modify our view configuration as appropriate:

simpleReport.(class)=org.springframework.web.servlet.view.jasperreports.JasperReportsPdfView simpleReport.url=/WEB-INF/reports/DataSourceReport.jasper simpleReport.reportDataKey=myBeanData

Be aware that when using the first approach, Spring will use the first instance of JRDataSourceor Collectionthat it encounters. If you need to place multiple instances of JRDataSourceor Collectioninto the model you need to use the second approach.

23.11.4 Working with Sub-Reports

JasperReports provides support for embedded sub-reports within your master report files. There are a wide variety of mechanisms for including sub-reports in your report files. The easiest way is to hard code the report path and the SQL query for the sub report into your design files. The drawback of this approach is obvious: the values are hard-coded into your report files reducing reusability and making it harder to modify and update report designs. To overcome this you can configure sub-reports declaratively, and you can include additional data for these sub-reports directly from your controllers.

Configuring Sub-Report Files

To control which sub-report files are included in a master report using Spring, your report file must be configured to accept sub-reports from an external source. To do this you declare a parameter in your report file like so:

									<parameter
									name=
									"ProductsSubReport"
									class=
									"net.sf.jasperreports.engine.JasperReport"
									/>

Then, you define your sub-report to use this sub-report parameter:

									<subreport>
									<reportElement
									isPrintRepeatedValues=
									"false"
									x=
									"5"
									y=
									"25"
									width=
									"325"
									height=
									"20"
									isRemoveLineWhenBlank=
									"true"
									backcolor=
									"#ffcc99"
									/>
									<subreportParameter
									name=
									"City"
									>
									<subreportParameterExpression>
									<![CDATA[$F{city}
									]]>
									</subreportParameterExpression>
									</subreportParameter>
									<dataSourceExpression>
									<![CDATA[$P{SubReportData}
									]]>
									</dataSourceExpression>
									<subreportExpression
									class=
									"net.sf.jasperreports.engine.JasperReport"
									>
									<![CDATA[$P{ProductsSubReport}
									]]>
									</subreportExpression>
									</subreport>

This defines a master report file that expects the sub-report to be passed in as an instance of net.sf.jasperreports.engine.JasperReportsunder the parameter ProductsSubReport. When configuring your Jasper view class, you can instruct Spring to load a report file and pass it into the JasperReports engine as a sub-report using the subReportUrlsproperty:

									<property
									name=
									"subReportUrls"
									>
									<map>
									<entry
									key=
									"ProductsSubReport"
									value=
									"/WEB-INF/reports/subReportChild.jrxml"
									/>
									</map>
									</property>

Here, the key of the Mapcorresponds to the name of the sub-report parameter in the report design file, and the entry is the URL of the report file. Spring will load this report file, compiling it if necessary, and pass it into the JasperReports engine under the given key.

Configuring Sub-Report Data Sources

This step is entirely optional when using Spring to configure your sub-reports. If you wish, you can still configure the data source for your sub-reports using static queries. However, if you want Spring to convert data returned in your ModelAndViewinto instances of JRDataSourcethen you need to specify which of the parameters in your ModelAndViewSpring should convert. To do this, configure the list of parameter names using the subReportDataKeysproperty of your chosen view class:

									<property
									name=
									"subReportDataKeys"
									value=
									"SubReportData"
									/>

Here, the key you supply mustcorrespond to both the key used in your ModelAndViewand the key used in your report design file.

23.11.5 Configuring Exporter Parameters

If you have special requirements for exporter configuration — perhaps you want a specific page size for your PDF report — you can configure these exporter parameters declaratively in your Spring configuration file using the exporterParametersproperty of the view class. The exporterParametersproperty is typed as a Map. In your configuration the key of an entry should be the fully-qualified name of a static field that contains the exporter parameter definition, and the value of an entry should be the value you want to assign to the parameter. An example of this is shown below:

								<bean
								id=
								"htmlReport"
								class=
								"org.springframework.web.servlet.view.jasperreports.JasperReportsHtmlView"
								>
								<property
								name=
								"url"
								value=
								"/WEB-INF/reports/simpleReport.jrxml"
								/>
								<property
								name=
								"exporterParameters"
								>
								<map>
								<entry
								key=
								"net.sf.jasperreports.engine.export.JRHtmlExporterParameter.HTML_FOOTER"
								>
								<value>Footer by Spring! &lt;/td&gt;&lt;td width="50%"&gt;&amp;nbsp; &lt;/td&gt;&lt;/tr&gt; &lt;/table&gt;&lt;/body&gt;&lt;/html&gt;
								</value>
								</entry>
								</map>
								</property>
								</bean>

Here you can see that the JasperReportsHtmlViewis configured with an exporter parameter for net.sf.jasperreports.engine.export.JRHtmlExporterParameter.HTML_FOOTERwhich will output a footer in the resulting HTML.

23.12 Feed Views

Both AbstractAtomFeedViewand AbstractRssFeedViewinherit from the base class AbstractFeedViewand are used to provide Atom and RSS Feed views respectfully. They are based on java.net’s ROMEproject and are located in the package org.springframework.web.servlet.view.feed.

AbstractAtomFeedViewrequires you to implement the buildFeedEntries()method and optionally override the buildFeedMetadata()method (the default implementation is empty), as shown below.

							public
							classSampleContentAtomView
							extendsAbstractAtomFeedView {
							
								@Override
							protected
							voidbuildFeedMetadata(Map<String, Object> model, Feed feed, HttpServletRequest request) {
							// implementation omitted}
							
								@Override
							protectedList<Entry> buildFeedEntries(Map<String, Object> model, HttpServletRequest request, HttpServletResponse response)
							throwsException {
							// implementation omitted} }

Similar requirements apply for implementing AbstractRssFeedView, as shown below.

							public
							classSampleContentAtomView
							extendsAbstractRssFeedView {
							
								@Override
							protected
							voidbuildFeedMetadata(Map<String, Object> model, Channel feed, HttpServletRequest request) {
							// implementation omitted}
							
								@Override
							protectedList<Item> buildFeedItems(Map<String, Object> model, HttpServletRequest request, HttpServletResponse response)
							throwsException {
							// implementation omitted} }

The buildFeedItems()and buildFeedEntires()methods pass in the HTTP request in case you need to access the Locale. The HTTP response is passed in only for the setting of cookies or other HTTP headers. The feed will automatically be written to the response object after the method returns.

For an example of creating an Atom view please refer to Alef Arendsen’s Spring Team Blog entry.

23.13 JSON Mapping View

The MappingJackson2JsonViewuses the Jackson library’s ObjectMapperto render the response content as JSON. By default, the entire contents of the model map (with the exception of framework-specific classes) will be encoded as JSON. For cases where the contents of the map need to be filtered, users may specify a specific set of model attributes to encode via the RenderedAttributesproperty. The extractValueFromSingleKeyModelproperty may also be used to have the value in single-key models extracted and serialized directly rather than as a map of model attributes.

JSON mapping can be customized as needed through the use of Jackson’s provided annotations. When further control is needed, a custom ObjectMappercan be injected through the ObjectMapperproperty for cases where custom JSON serializers/deserializers need to be provided for specific types.

JSONPis supported and automatically enabled when the request has a query parameter named jsonpor callback. The JSONP query parameter name(s) could be customized through the jsonpParameterNamesproperty.

23.14 XML Mapping View

The MappingJackson2XmlViewuses the Jackson XML extension's XmlMapperto render the response content as XML. If the model contains multiples entries, the object to be serialized should be set explicitly using the modelKeybean property. If the model contains a single entry, it will be serialized automatically.

XML mapping can be customized as needed through the use of JAXB or Jackson’s provided annotations. When further control is needed, a custom XmlMappercan be injected through the ObjectMapperproperty for cases where custom XML serializers/deserializers need to be provided for specific types.

24. Integrating with other web frameworks

24.1 Introduction

Spring Web Flow

Spring Web Flow (SWF) aims to be the best solution for the management of web application page flow.

SWF integrates with existing frameworks like Spring MVC and JSF, in both Servlet and Portlet environments. If you have a business process (or processes) that would benefit from a conversational model as opposed to a purely request model, then SWF may be the solution.

SWF allows you to capture logical page flows as self-contained modules that are reusable in different situations, and as such is ideal for building web application modules that guide the user through controlled navigations that drive business processes.

For more information about SWF, consult the Spring Web Flow website.

This chapter details Spring’s integration with third party web frameworks, such as JSF.

One of the core value propositions of the Spring Framework is that of enabling choice. In a general sense, Spring does not force one to use or buy into any particular architecture, technology, or methodology (although it certainly recommends some over others). This freedom to pick and choose the architecture, technology, or methodology that is most relevant to a developer and their development team is arguably most evident in the web area, where Spring provides its own web framework ( Spring MVC), while at the same time providing integration with a number of popular third party web frameworks. This allows one to continue to leverage any and all of the skills one may have acquired in a particular web framework such as JSF, while at the same time being able to enjoy the benefits afforded by Spring in other areas such as data access, declarative transaction management, and flexible configuration and application assembly.

Having dispensed with the woolly sales patter (c.f. the previous paragraph), the remainder of this chapter will concentrate upon the meaty details of integrating your favorite web framework with Spring. One thing that is often commented upon by developers coming to Java from other languages is the seeming super-abundance of web frameworks available in Java. There are indeed a great number of web frameworks in the Java space; in fact there are far too many to cover with any semblance of detail in a single chapter. This chapter thus picks four of the more popular web frameworks in Java, starting with the Spring configuration that is common to all of the supported web frameworks, and then detailing the specific integration options for each supported web framework.

[Note] Note

Please note that this chapter does not attempt to explain how to use any of the supported web frameworks. For example, if you want to use JSF for the presentation layer of your web application, the assumption is that you are already familiar with JSF itself. If you need further details about any of the supported web frameworks themselves, please do consult Section 24.6, “Further Resources”at the end of this chapter.

24.2 Common configuration

Before diving into the integration specifics of each supported web framework, let us first take a look at the Spring configuration that is notspecific to any one web framework. (This section is equally applicable to Spring’s own web framework, Spring MVC.)

One of the concepts (for want of a better word) espoused by (Spring’s) lightweight application model is that of a layered architecture. Remember that in a 'classic' layered architecture, the web layer is but one of many layers; it serves as one of the entry points into a server side application and it delegates to service objects (facades) defined in a service layer to satisfy business specific (and presentation-technology agnostic) use cases. In Spring, these service objects, any other business-specific objects, data access objects, etc. exist in a distinct 'business context', which contains noweb or presentation layer objects (presentation objects such as Spring MVC controllers are typically configured in a distinct 'presentation context'). This section details how one configures a Spring container (a WebApplicationContext) that contains all of the 'business beans' in one’s application.

On to specifics: all that one need do is to declare a ContextLoaderListenerin the standard Java EE servlet web.xmlfile of one’s web application, and add a contextConfigLocation<context-param/> section (in the same file) that defines which set of Spring XML configuration files to load.

Find below the <listener/> configuration:

							<listener>
							<listener-class>org.springframework.web.context.ContextLoaderListener
							</listener-class>
							</listener>

Find below the <context-param/> configuration:

							<context-param>
							<param-name>contextConfigLocation
							</param-name>
							<param-value>/WEB-INF/applicationContext*.xml
							</param-value>
							</context-param>

If you don’t specify the contextConfigLocationcontext parameter, the ContextLoaderListenerwill look for a file called /WEB-INF/applicationContext.xmlto load. Once the context files are loaded, Spring creates a WebApplicationContextobject based on the bean definitions and stores it in the ServletContextof the web application.

All Java web frameworks are built on top of the Servlet API, and so one can use the following code snippet to get access to this 'business context' ApplicationContextcreated by the ContextLoaderListener.

WebApplicationContext ctx = WebApplicationContextUtils.getWebApplicationContext(servletContext);

The WebApplicationContextUtilsclass is for convenience, so you don’t have to remember the name of the ServletContextattribute. Its getWebApplicationContext()method will return nullif an object doesn’t exist under the WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTEkey. Rather than risk getting NullPointerExceptionsin your application, it’s better to use the getRequiredWebApplicationContext()method. This method throws an exception when the ApplicationContextis missing.

Once you have a reference to the WebApplicationContext, you can retrieve beans by their name or type. Most developers retrieve beans by name and then cast them to one of their implemented interfaces.

Fortunately, most of the frameworks in this section have simpler ways of looking up beans. Not only do they make it easy to get beans from a Spring container, but they also allow you to use dependency injection on their controllers. Each web framework section has more detail on its specific integration strategies.

24.3 JavaServer Faces 1.2

JavaServer Faces (JSF) is the JCP’s standard component-based, event-driven web user interface framework. As of Java EE 5, it is an official part of the Java EE umbrella.

For a popular JSF runtime as well as for popular JSF component libraries, check out the Apache MyFaces project. The MyFaces project also provides common JSF extensions such as MyFaces Orchestra: a Spring-based JSF extension that provides rich conversation scope support.

[Note] Note

Spring Web Flow 2.0 provides rich JSF support through its newly established Spring Faces module, both for JSF-centric usage (as described in this section) and for Spring-centric usage (using JSF views within a Spring MVC dispatcher). Check out the Spring Web Flow websitefor details!

The key element in Spring’s JSF integration is the JSF ELResolvermechanism.

24.3.1 SpringBeanFacesELResolver (JSF 1.2+)

SpringBeanFacesELResolveris a JSF 1.2 compliant ELResolverimplementation, integrating with the standard Unified EL as used by JSF 1.2 and JSP 2.1. Like SpringBeanVariableResolver, it delegates to the Spring’s 'business context' WebApplicationContext first, then to the default resolver of the underlying JSF implementation.

Configuration-wise, simply define SpringBeanFacesELResolverin your JSF 1.2 faces-context.xmlfile:

								<faces-config>
								<application>
								<el-resolver>org.springframework.web.jsf.el.SpringBeanFacesELResolver
								</el-resolver>...
								</application>
								</faces-config>

24.3.2 FacesContextUtils

A custom VariableResolverworks well when mapping one’s properties to beans in faces-config.xml, but at times one may need to grab a bean explicitly. The FacesContextUtilsclass makes this easy. It is similar to WebApplicationContextUtils, except that it takes a FacesContextparameter rather than a ServletContextparameter.

ApplicationContext ctx = FacesContextUtils.getWebApplicationContext(FacesContext.getCurrentInstance());

24.4 Apache Struts 2.x

Invented by Craig McClanahan, Strutsis an open source project hosted by the Apache Software Foundation. At the time, it greatly simplified the JSP/Servlet programming paradigm and won over many developers who were using proprietary frameworks. It simplified the programming model, it was open source (and thus free as in beer), and it had a large community, which allowed the project to grow and become popular among Java web developers.

Check out the Struts Spring Pluginfor the built-in Spring integration shipped with Struts.

24.5 Tapestry 5.x

From the Tapestry homepage:

Tapestry is a " Component oriented framework for creating dynamic, robust, highly scalable web applications in Java."

While Spring has its own powerful web layer, there are a number of unique advantages to building an enterprise Java application using a combination of Tapestry for the web user interface and the Spring container for the lower layers.

For more information, check out Tapestry’s dedicated integration module for Spring.

24.6 Further Resources

Find below links to further resources about the various web frameworks described in this chapter.

25. Portlet MVC Framework

25.1 Introduction

JSR-286 The Java Portlet Specification

For more general information about portlet development, please review the JSR-286 Specificationitself.

In addition to supporting conventional (servlet-based) Web development, Spring also supports JSR-286 Portlet development. As much as possible, the Portlet MVC framework is a mirror image of the Web MVC framework, and also uses the same underlying view abstractions and integration technology. So, be sure to review the chapters entitled Chapter 22, Web MVC framework and Chapter 23, View technologies before continuing with this chapter.

[Note] Note

Bear in mind that while the concepts of Spring MVC are the same in Spring Portlet MVC, there are some notable differences created by the unique workflow of JSR-286 portlets.

The main way in which portlet workflow differs from servlet workflow is that the request to the portlet can have two distinct phases: the action phase and the render phase. The action phase is executed only once and is where any 'backend' changes or actions occur, such as making changes in a database. The render phase then produces what is displayed to the user each time the display is refreshed. The critical point here is that for a single overall request, the action phase is executed only once, but the render phase may be executed multiple times. This provides (and requires) a clean separation between the activities that modify the persistent state of your system and the activities that generate what is displayed to the user.

Spring Web Flow

Spring Web Flow (SWF) aims to be the best solution for the management of web application page flow.

SWF integrates with existing frameworks like Spring MVC and JSF, in both Servlet and Portlet environments. If you have a business process (or processes) that would benefit from a conversational model as opposed to a purely request model, then SWF may be the solution.

SWF allows you to capture logical page flows as self-contained modules that are reusable in different situations, and as such is ideal for building web application modules that guide the user through controlled navigations that drive business processes.

For more information about SWF, consult the Spring Web Flow website.

The dual phases of portlet requests are one of the real strengths of the JSR-286 specification. For example, dynamic search results can be updated routinely on the display without the user explicitly rerunning the search. Most other portlet MVC frameworks attempt to completely hide the two phases from the developer and make it look as much like traditional servlet development as possible - we think this approach removes one of the main benefits of using portlets. So, the separation of the two phases is preserved throughout the Spring Portlet MVC framework. The primary manifestation of this approach is that where the servlet version of the MVC classes will have one method that deals with the request, the portlet version of the MVC classes will have two methods that deal with the request: one for the action phase and one for the render phase. For example, where the servlet version of AbstractControllerhas the handleRequestInternal(..)method, the portlet version of AbstractControllerhas handleActionRequestInternal(..)and handleRenderRequestInternal(..)methods.

The framework is designed around a DispatcherPortletthat dispatches requests to handlers, with configurable handler mappings and view resolution, just as the DispatcherServletin the web framework does. File upload is also supported in the same way.

Locale resolution and theme resolution are not supported in Portlet MVC - these areas are in the purview of the portal/portlet container and are not appropriate at the Spring level. However, all mechanisms in Spring that depend on the locale (such as internationalization of messages) will still function properly because DispatcherPortletexposes the current locale in the same way as DispatcherServlet.

25.1.1 Controllers - The C in MVC

The default handler is still a very simple Controllerinterface, offering just two methods:

  • void handleActionRequest(request,response)
  • ModelAndView handleRenderRequest(request,response)

The framework also includes most of the same controller implementation hierarchy, such as AbstractController, SimpleFormController, and so on. Data binding, command object usage, model handling, and view resolution are all the same as in the servlet framework.

25.1.2 Views - The V in MVC

All the view rendering capabilities of the servlet framework are used directly via a special bridge servlet named ViewRendererServlet. By using this servlet, the portlet request is converted into a servlet request and the view can be rendered using the entire normal servlet infrastructure. This means all the existing renderers, such as JSP, Velocity, etc., can still be used within the portlet.

25.1.3 Web-scoped beans

Spring Portlet MVC supports beans whose lifecycle is scoped to the current HTTP request or HTTP Session(both normal and global). This is not a specific feature of Spring Portlet MVC itself, but rather of the WebApplicationContextcontainer(s) that Spring Portlet MVC uses. These bean scopes are described in detail in Section 7.5.4, “Request, session, global session, application, and WebSocket scopes”

25.2 The DispatcherPortlet

Portlet MVC is a request-driven web MVC framework, designed around a portlet that dispatches requests to controllers and offers other functionality facilitating the development of portlet applications. Spring’s DispatcherPortlethowever, does more than just that. It is completely integrated with the Spring ApplicationContextand allows you to use every other feature Spring has.

Like ordinary portlets, the DispatcherPortletis declared in the portlet.xmlfile of your web application:

							<portlet>
							<portlet-name>sample
							</portlet-name>
							<portlet-class>org.springframework.web.portlet.DispatcherPortlet
							</portlet-class>
							<supports>
							<mime-type>text/html
							</mime-type>
							<portlet-mode>view
							</portlet-mode>
							</supports>
							<portlet-info>
							<title>Sample Portlet
							</title>
							</portlet-info>
							</portlet>

The DispatcherPortletnow needs to be configured.

In the Portlet MVC framework, each DispatcherPortlethas its own WebApplicationContext, which inherits all the beans already defined in the Root WebApplicationContext. These inherited beans can be overridden in the portlet-specific scope, and new scope-specific beans can be defined local to a given portlet instance.

The framework will, on initialization of a DispatcherPortlet, look for a file named [portlet-name]-portlet.xmlin the WEB-INFdirectory of your web application and create the beans defined there (overriding the definitions of any beans defined with the same name in the global scope).

The config location used by the DispatcherPortletcan be modified through a portlet initialization parameter (see below for details).

The Spring DispatcherPortlethas a few special beans it uses, in order to be able to process requests and render the appropriate views. These beans are included in the Spring framework and can be configured in the WebApplicationContext, just as any other bean would be configured. Each of those beans is described in more detail below. Right now, we’ll just mention them, just to let you know they exist and to enable us to go on talking about the DispatcherPortlet. For most of the beans, defaults are provided so you don’t have to worry about configuring them.

Table 25.1. Special beans in the WebApplicationContext

Expression Explanation

handler mapping(s)

( Section 25.5, “Handler mappings”) a list of pre- and post-processors and controllers that will be executed if they match certain criteria (for instance a matching portlet mode specified with the controller)

controller(s)

( Section 25.4, “Controllers”) the beans providing the actual functionality (or at least, access to the functionality) as part of the MVC triad

view resolver

( Section 25.6, “Views and resolving them”) capable of resolving view names to view definitions

multipart resolver

( Section 25.7, “Multipart (file upload) support”) offers functionality to process file uploads from HTML forms

handler exception resolver

( Section 25.8, “Handling exceptions”) offers functionality to map exceptions to views or implement other more complex exception handling code

When a DispatcherPortletis setup for use and a request comes in for that specific DispatcherPortlet, it starts processing the request. The list below describes the complete process a request goes through if handled by a DispatcherPortlet:

  1. The locale returned by PortletRequest.getLocale()is bound to the request to let elements in the process resolve the locale to use when processing the request (rendering the view, preparing data, etc.).
  2. If a multipart resolver is specified and this is an ActionRequest, the request is inspected for multiparts and if they are found, it is wrapped in a MultipartActionRequestfor further processing by other elements in the process. (See Section 25.7, “Multipart (file upload) support”for further information about multipart handling).
  3. An appropriate handler is searched for. If a handler is found, the execution chain associated with the handler (pre-processors, post-processors, controllers) will be executed in order to prepare a model.
  4. If a model is returned, the view is rendered, using the view resolver that has been configured with the WebApplicationContext. If no model is returned (which could be due to a pre- or post-processor intercepting the request, for example, for security reasons), no view is rendered, since the request could already have been fulfilled.

Exceptions that are thrown during processing of the request get picked up by any of the handler exception resolvers that are declared in the WebApplicationContext. Using these exception resolvers you can define custom behavior in case such exceptions get thrown.

You can customize Spring’s DispatcherPortletby adding context parameters in the portlet.xmlfile or portlet init-parameters. The possibilities are listed below.

Table 25.2. DispatcherPortlet initialization parameters

Parameter Explanation

contextClass

Class that implements WebApplicationContext, which will be used to instantiate the context used by this portlet. If this parameter isn’t specified, the XmlPortletApplicationContextwill be used.

contextConfigLocation

String which is passed to the context instance (specified by contextClass) to indicate where context(s) can be found. The String is potentially split up into multiple Strings (using a comma as a delimiter) to support multiple contexts (in case of multiple context locations, for beans that are defined twice, the latest takes precedence).

namespace

The namespace of the WebApplicationContext. Defaults to [portlet-name]-portlet.

viewRendererUrl

The URL at which DispatcherPortletcan access an instance of ViewRendererServlet(see Section 25.3, “The ViewRendererServlet”).

25.3 The ViewRendererServlet

The rendering process in Portlet MVC is a bit more complex than in Web MVC. In order to reuse all the view technologiesfrom Spring Web MVC, we must convert the PortletRequest/ PortletResponseto HttpServletRequest/ HttpServletResponseand then call the rendermethod of the View. To do this, DispatcherPortletuses a special servlet that exists for just this purpose: the ViewRendererServlet.

In order for DispatcherPortletrendering to work, you must declare an instance of the ViewRendererServletin the web.xmlfile for your web application as follows:

							<servlet>
							<servlet-name>ViewRendererServlet
							</servlet-name>
							<servlet-class>org.springframework.web.servlet.ViewRendererServlet
							</servlet-class>
							</servlet>
							<servlet-mapping>
							<servlet-name>ViewRendererServlet
							</servlet-name>
							<url-pattern>/WEB-INF/servlet/view
							</url-pattern>
							</servlet-mapping>

To perform the actual rendering, DispatcherPortletdoes the following:

  1. Binds the WebApplicationContextto the request as an attribute under the same WEB_APPLICATION_CONTEXT_ATTRIBUTEkey that DispatcherServletuses.
  2. Binds the Modeland Viewobjects to the request to make them available to the ViewRendererServlet.
  3. Constructs a PortletRequestDispatcherand performs an includeusing the /WEB- INF/servlet/viewURL that is mapped to the ViewRendererServlet.

The ViewRendererServletis then able to call the rendermethod on the Viewwith the appropriate arguments.

The actual URL for the ViewRendererServletcan be changed using DispatcherPortlet’s `viewRendererUrlconfiguration parameter.

25.4 Controllers

The controllers in Portlet MVC are very similar to the Web MVC Controllers, and porting code from one to the other should be simple.

The basis for the Portlet MVC controller architecture is the org.springframework.web.portlet.mvc.Controllerinterface, which is listed below.

							public
							interfaceController {
							/** * Process the render request and return a ModelAndView object which the * DispatcherPortlet will render. */ModelAndView handleRenderRequest(RenderRequest request, RenderResponse response)
							throwsException;
							/** * Process the action request. There is nothing to return. */
							voidhandleActionRequest(ActionRequest request, ActionResponse response)
							throwsException; }

As you can see, the Portlet Controllerinterface requires two methods that handle the two phases of a portlet request: the action request and the render request. The action phase should be capable of handling an action request, and the render phase should be capable of handling a render request and returning an appropriate model and view. While the Controllerinterface is quite abstract, Spring Portlet MVC offers several controllers that already contain a lot of the functionality you might need; most of these are very similar to controllers from Spring Web MVC. The Controllerinterface just defines the most common functionality required of every controller: handling an action request, handling a render request, and returning a model and a view.

25.4.1 AbstractController and PortletContentGenerator

Of course, just a Controllerinterface isn’t enough. To provide a basic infrastructure, all of Spring Portlet MVC’s Controllers inherit from AbstractController, a class offering access to Spring’s ApplicationContextand control over caching.

Table 25.3. Features offered by the AbstractController

Parameter Explanation

requireSession

Indicates whether or not this Controllerrequires a session to do its work. This feature is offered to all controllers. If a session is not present when such a controller receives a request, the user is informed using a SessionRequiredException.

synchronizeSession

Use this if you want handling by this controller to be synchronized on the user’s session. To be more specific, the extending controller will override the handleRenderRequestInternal(..)and handleActionRequestInternal(..)methods, which will be synchronized on the user’s session if you specify this variable.

renderWhenMinimized

If you want your controller to actually render the view when the portlet is in a minimized state, set this to true. By default, this is set to false so that portlets that are in a minimized state don’t display any content.

cacheSeconds

When you want a controller to override the default cache expiration defined for the portlet, specify a positive integer here. By default it is set to -1, which does not change the default caching. Setting it to 0will ensure the result is never cached.

The requireSessionand cacheSecondsproperties are declared on the PortletContentGeneratorclass, which is the superclass of AbstractController) but are included here for completeness.

When using the AbstractControlleras a base class for your controllers (which is not recommended since there are a lot of other controllers that might already do the job for you) you only have to override either the handleActionRequestInternal(ActionRequest, ActionResponse)method or the handleRenderRequestInternal(RenderRequest, RenderResponse)method (or both), implement your logic, and return a ModelAndViewobject (in the case of handleRenderRequestInternal).

The default implementations of both handleActionRequestInternal(..)and handleRenderRequestInternal(..)throw a PortletException. This is consistent with the behavior of GenericPortletfrom the JSR- 168 Specification API. So you only need to override the method that your controller is intended to handle.

Here is short example consisting of a class and a declaration in the web application context.

								packagesamples;
								importjavax.portlet.RenderRequest;
								importjavax.portlet.RenderResponse;
								importorg.springframework.web.portlet.mvc.AbstractController;
								importorg.springframework.web.portlet.ModelAndView;
								public
								classSampleController
								extendsAbstractController {
								publicModelAndView handleRenderRequestInternal(RenderRequest request, RenderResponse response) { ModelAndView mav =
								newModelAndView(
								"foo"); mav.addObject(
								"message",
								"Hello World!");
								returnmav; } }
								<bean
								id=
								"sampleController"
								class=
								"samples.SampleController"
								>
								<property
								name=
								"cacheSeconds"
								value=
								"120"
								/>
								</bean>

The class above and the declaration in the web application context is all you need besides setting up a handler mapping (see Section 25.5, “Handler mappings”) to get this very simple controller working.

25.4.2 Other simple controllers

Although you can extend AbstractController, Spring Portlet MVC provides a number of concrete implementations which offer functionality that is commonly used in simple MVC applications.

The ParameterizableViewControlleris basically the same as the example above, except for the fact that you can specify the view name that it will return in the web application context (no need to hard-code the view name).

The PortletModeNameViewControlleruses the current mode of the portlet as the view name. So, if your portlet is in View mode (i.e. PortletMode.VIEW) then it uses "view" as the view name.

25.4.3 Command Controllers

Spring Portlet MVC has the exact same hierarchy of command controllersas Spring Web MVC. They provide a way to interact with data objects and dynamically bind parameters from the PortletRequestto the data object specified. Your data objects don’t have to implement a framework-specific interface, so you can directly manipulate your persistent objects if you desire. Let’s examine what command controllers are available, to get an overview of what you can do with them:

  • AbstractCommandController- a command controller you can use to create your own command controller, capable of binding request parameters to a data object you specify. This class does not offer form functionality, it does however offer validation features and lets you specify in the controller itself what to do with the command object that has been filled with the parameters from the request.
  • AbstractFormController- an abstract controller offering form submission support. Using this controller you can model forms and populate them using a command object you retrieve in the controller. After a user has filled the form, AbstractFormControllerbinds the fields, validates, and hands the object back to the controller to take appropriate action. Supported features are: invalid form submission (resubmission), validation, and normal form workflow. You implement methods to determine which views are used for form presentation and success. Use this controller if you need forms, but don’t want to specify what views you’re going to show the user in the application context.
  • SimpleFormController- a concrete AbstractFormControllerthat provides even more support when creating a form with a corresponding command object. The SimpleFormControllerlets you specify a command object, a viewname for the form, a viewname for the page you want to show the user when form submission has succeeded, and more.
  • AbstractWizardFormController — a concrete AbstractFormControllerthat provides a wizard-style interface for editing the contents of a command object across multiple display pages. Supports multiple user actions: finish, cancel, or page change, all of which are easily specified in request parameters from the view.

These command controllers are quite powerful, but they do require a detailed understanding of how they operate in order to use them efficiently. Carefully review the javadocs for this entire hierarchy and then look at some sample implementations before you start using them.

25.4.4 PortletWrappingController

Instead of developing new controllers, it is possible to use existing portlets and map requests to them from a DispatcherPortlet. Using the PortletWrappingController, you can instantiate an existing Portletas a Controlleras follows:

								<bean
								id=
								"myPortlet"
								class=
								"org.springframework.web.portlet.mvc.PortletWrappingController"
								>
								<property
								name=
								"portletClass"
								value=
								"sample.MyPortlet"
								/>
								<property
								name=
								"portletName"
								value=
								"my-portlet"
								/>
								<property
								name=
								"initParameters"
								>
								<value>config=/WEB-INF/my-portlet-config.xml
								</value>
								</property>
								</bean>

This can be very valuable since you can then use interceptors to pre-process and post-process requests going to these portlets. Since JSR-286 does not support any kind of filter mechanism, this is quite handy. For example, this can be used to wrap the Hibernate OpenSessionInViewInterceptoraround a MyFaces JSF Portlet.

25.5 Handler mappings

Using a handler mapping you can map incoming portlet requests to appropriate handlers. There are some handler mappings you can use out of the box, for example, the PortletModeHandlerMapping, but let’s first examine the general concept of a HandlerMapping.

Note: We are intentionally using the term "Handler" here instead of "Controller". DispatcherPortletis designed to be used with other ways to process requests than just Spring Portlet MVC’s own Controllers. A Handler is any Object that can handle portlet requests. Controllers are an example of Handlers, and they are of course the default. To use some other framework with DispatcherPortlet, a corresponding implementation of HandlerAdapteris all that is needed.

The functionality a basic HandlerMappingprovides is the delivering of a HandlerExecutionChain, which must contain the handler that matches the incoming request, and may also contain a list of handler interceptors that are applied to the request. When a request comes in, the DispatcherPortletwill hand it over to the handler mapping to let it inspect the request and come up with an appropriate HandlerExecutionChain. Then the DispatcherPortletwill execute the handler and interceptors in the chain (if any). These concepts are all exactly the same as in Spring Web MVC.

The concept of configurable handler mappings that can optionally contain interceptors (executed before or after the actual handler was executed, or both) is extremely powerful. A lot of supporting functionality can be built into a custom HandlerMapping. Think of a custom handler mapping that chooses a handler not only based on the portlet mode of the request coming in, but also on a specific state of the session associated with the request.

In Spring Web MVC, handler mappings are commonly based on URLs. Since there is really no such thing as a URL within a Portlet, we must use other mechanisms to control mappings. The two most common are the portlet mode and a request parameter, but anything available to the portlet request can be used in a custom handler mapping.

The rest of this section describes three of Spring Portlet MVC’s most commonly used handler mappings. They all extend AbstractHandlerMappingand share the following properties:

  • interceptors: The list of interceptors to use. HandlerInterceptors are discussed in Section 25.5.4, “Adding HandlerInterceptors”.
  • defaultHandler: The default handler to use, when this handler mapping does not result in a matching handler.
  • order: Based on the value of the order property (see the org.springframework.core.Orderedinterface), Spring will sort all handler mappings available in the context and apply the first matching handler.
  • lazyInitHandlers: Allows for lazy initialization of singleton handlers (prototype handlers are always lazily initialized). Default value is false. This property is directly implemented in the three concrete Handlers.

25.5.1 PortletModeHandlerMapping

This is a simple handler mapping that maps incoming requests based on the current mode of the portlet (e.g. 'view', 'edit', 'help'). An example:

								<bean
								class=
								"org.springframework.web.portlet.handler.PortletModeHandlerMapping"
								>
								<property
								name=
								"portletModeMap"
								>
								<map>
								<entry
								key=
								"view"
								value-ref=
								"viewHandler"
								/>
								<entry
								key=
								"edit"
								value-ref=
								"editHandler"
								/>
								<entry
								key=
								"help"
								value-ref=
								"helpHandler"
								/>
								</map>
								</property>
								</bean>

25.5.2 ParameterHandlerMapping

If we need to navigate around to multiple controllers without changing portlet mode, the simplest way to do this is with a request parameter that is used as the key to control the mapping.

ParameterHandlerMappinguses the value of a specific request parameter to control the mapping. The default name of the parameter is 'action', but can be changed using the 'parameterName'property.

The bean configuration for this mapping will look something like this:

								<bean
								class=
								"org.springframework.web.portlet.handler.ParameterHandlerMapping"
								>
								<property
								name=
								"parameterMap"
								>
								<map>
								<entry
								key=
								"add"
								value-ref=
								"addItemHandler"
								/>
								<entry
								key=
								"edit"
								value-ref=
								"editItemHandler"
								/>
								<entry
								key=
								"delete"
								value-ref=
								"deleteItemHandler"
								/>
								</map>
								</property>
								</bean>

25.5.3 PortletModeParameterHandlerMapping

The most powerful built-in handler mapping, PortletModeParameterHandlerMappingcombines the capabilities of the two previous ones to allow different navigation within each portlet mode.

Again the default name of the parameter is "action", but can be changed using the parameterNameproperty.

By default, the same parameter value may not be used in two different portlet modes. This is so that if the portal itself changes the portlet mode, the request will no longer be valid in the mapping. This behavior can be changed by setting the allowDupParametersproperty to true. However, this is not recommended.

The bean configuration for this mapping will look something like this:

								<bean
								class=
								"org.springframework.web.portlet.handler.PortletModeParameterHandlerMapping"
								>
								<property
								name=
								"portletModeParameterMap"
								>
								<map>
								<entry
								key=
								"view"
								>
								<!-- 'view' portlet mode -->
								<map>
								<entry
								key=
								"add"
								value-ref=
								"addItemHandler"
								/>
								<entry
								key=
								"edit"
								value-ref=
								"editItemHandler"
								/>
								<entry
								key=
								"delete"
								value-ref=
								"deleteItemHandler"
								/>
								</map>
								</entry>
								<entry
								key=
								"edit"
								>
								<!-- 'edit' portlet mode -->
								<map>
								<entry
								key=
								"prefs"
								value-ref=
								"prefsHandler"
								/>
								<entry
								key=
								"resetPrefs"
								value-ref=
								"resetPrefsHandler"
								/>
								</map>
								</entry>
								</map>
								</property>
								</bean>

This mapping can be chained ahead of a PortletModeHandlerMapping, which can then provide defaults for each mode and an overall default as well.

25.5.4 Adding HandlerInterceptors

Spring’s handler mapping mechanism has a notion of handler interceptors, which can be extremely useful when you want to apply specific functionality to certain requests, for example, checking for a principal. Again Spring Portlet MVC implements these concepts in the same way as Web MVC.

Interceptors located in the handler mapping must implement HandlerInterceptorfrom the org.springframework.web.portletpackage. Just like the servlet version, this interface defines three methods: one that will be called before the actual handler will be executed ( preHandle), one that will be called after the handler is executed ( postHandle), and one that is called after the complete request has finished ( afterCompletion). These three methods should provide enough flexibility to do all kinds of pre- and post- processing.

The preHandlemethod returns a boolean value. You can use this method to break or continue the processing of the execution chain. When this method returns true, the handler execution chain will continue. When it returns false, the DispatcherPortletassumes the interceptor itself has taken care of requests (and, for example, rendered an appropriate view) and does not continue executing the other interceptors and the actual handler in the execution chain.

The postHandlemethod is only called on a RenderRequest. The preHandleand afterCompletionmethods are called on both an ActionRequestand a RenderRequest. If you need to execute logic in these methods for just one type of request, be sure to check what kind of request it is before processing it.

25.5.5 HandlerInterceptorAdapter

As with the servlet package, the portlet package has a concrete implementation of HandlerInterceptorcalled HandlerInterceptorAdapter. This class has empty versions of all the methods so that you can inherit from this class and implement just one or two methods when that is all you need.

25.5.6 ParameterMappingInterceptor

The portlet package also has a concrete interceptor named ParameterMappingInterceptorthat is meant to be used directly with ParameterHandlerMappingand PortletModeParameterHandlerMapping. This interceptor will cause the parameter that is being used to control the mapping to be forwarded from an ActionRequestto the subsequent RenderRequest. This will help ensure that the RenderRequestis mapped to the same Handler as the ActionRequest. This is done in the preHandlemethod of the interceptor, so you can still modify the parameter value in your handler to change where the RenderRequestwill be mapped.

Be aware that this interceptor is calling setRenderParameteron the ActionResponse, which means that you cannot call sendRedirectin your handler when using this interceptor. If you need to do external redirects then you will either need to forward the mapping parameter manually or write a different interceptor to handle this for you.

25.6 Views and resolving them

As mentioned previously, Spring Portlet MVC directly reuses all the view technologies from Spring Web MVC. This includes not only the various Viewimplementations themselves, but also the ViewResolverimplementations. For more information, refer to Chapter 23, View technologies and Section 22.5, “Resolving views”respectively.

A few items on using the existing Viewand ViewResolverimplementations are worth mentioning:

  • Most portals expect the result of rendering a portlet to be an HTML fragment. So, things like JSP/JSTL, Velocity, FreeMarker, and XSLT all make sense. But it is unlikely that views that return other document types will make any sense in a portlet context.
  • There is no such thing as an HTTP redirect from within a portlet (the sendRedirect(..)method of ActionResponsecannot be used to stay within the portal). So, RedirectViewand use of the 'redirect:'prefix will notwork correctly from within Portlet MVC.
  • It may be possible to use the 'forward:'prefix from within Portlet MVC. However, remember that since you are in a portlet, you have no idea what the current URL looks like. This means you cannot use a relative URL to access other resources in your web application and that you will have to use an absolute URL.

Also, for JSP development, the new Spring Taglib and the new Spring Form Taglib both work in portlet views in exactly the same way that they work in servlet views.

25.7 Multipart (file upload) support

Spring Portlet MVC has built-in multipart support to handle file uploads in portlet applications, just like Web MVC does. The design for the multipart support is done with pluggable PortletMultipartResolverobjects, defined in the org.springframework.web.portlet.multipartpackage. Spring provides a PortletMultipartResolverfor use with Commons FileUpload. How uploading files is supported will be described in the rest of this section.

By default, no multipart handling will be done by Spring Portlet MVC, as some developers will want to handle multiparts themselves. You will have to enable it yourself by adding a multipart resolver to the web application’s context. After you have done that, DispatcherPortletwill inspect each request to see if it contains a multipart. If no multipart is found, the request will continue as expected. However, if a multipart is found in the request, the PortletMultipartResolverthat has been declared in your context will be used. After that, the multipart attribute in your request will be treated like any other attribute.

[Note] Note

Any configured PortletMultipartResolverbean musthave the following id (or name): " portletMultipartResolver`". If you have defined your `PortletMultipartResolverwith any other name, then the DispatcherPortletwill notfind your PortletMultipartResolver, and consequently no multipart support will be in effect.

25.7.1 Using the PortletMultipartResolver

The following example shows how to use the CommonsPortletMultipartResolver:

								<bean
								id=
								"portletMultipartResolver"
								class=
								"org.springframework.web.portlet.multipart.CommonsPortletMultipartResolver"
								>
								<!-- one of the properties available; the maximum file size in bytes -->
								<property
								name=
								"maxUploadSize"
								value=
								"100000"
								/>
								</bean>

Of course you also need to put the appropriate jars in your classpath for the multipart resolver to work. In the case of the CommonsMultipartResolver, you need to use commons-fileupload.jar. Be sure to use at least version 1.1 of Commons FileUpload as previous versions do not support JSR-286 Portlet applications.

Now that you have seen how to set Portlet MVC up to handle multipart requests, let’s talk about how to actually use it. When DispatcherPortletdetects a multipart request, it activates the resolver that has been declared in your context and hands over the request. What the resolver then does is wrap the current ActionRequestin a MultipartActionRequestthat has support for multipart file uploads. Using the MultipartActionRequestyou can get information about the multiparts contained by this request and actually get access to the multipart files themselves in your controllers.

Note that you can only receive multipart file uploads as part of an ActionRequest, not as part of a RenderRequest.

25.7.2 Handling a file upload in a form

After the PortletMultipartResolverhas finished doing its job, the request will be processed like any other. To use the PortletMultipartResolver, create a form with an upload field (see example below), then let Spring bind the file onto your form (backing object). To actually let the user upload a file, we have to create a (JSP/HTML) form:

								<h1>Please upload a file
								</h1>
								<form
								method=
								"post"
								action=
								"<portlet:actionURL/>"
								enctype=
								"multipart/form-data"
								>
								<input
								type=
								"file"
								name=
								"file"
								/>
								<input
								type=
								"submit"
								/>
								</form>

As you can see, we’ve created a field named "file" that matches the property of the bean that holds the byte[]array. Furthermore we’ve added the encoding attribute ( enctype="multipart/form-data"), which is necessary to let the browser know how to encode the multipart fields (do not forget this!).

Just as with any other property that’s not automagically convertible to a string or primitive type, to be able to put binary data in your objects you have to register a custom editor with the PortletRequestDataBinder. There are a couple of editors available for handling files and setting the results on an object. There’s a StringMultipartFileEditorcapable of converting files to Strings (using a user-defined character set), and there is a ByteArrayMultipartFileEditorwhich converts files to byte arrays. They function analogous to the CustomDateEditor.

So, to be able to upload files using a form, declare the resolver, a mapping to a controller that will process the bean, and the controller itself.

								<bean
								id=
								"portletMultipartResolver"
								class=
								"org.springframework.web.portlet.multipart.CommonsPortletMultipartResolver"
								/>
								<bean
								class=
								"org.springframework.web.portlet.handler.PortletModeHandlerMapping"
								>
								<property
								name=
								"portletModeMap"
								>
								<map>
								<entry
								key=
								"view"
								value-ref=
								"fileUploadController"
								/>
								</map>
								</property>
								</bean>
								<bean
								id=
								"fileUploadController"
								class=
								"examples.FileUploadController"
								>
								<property
								name=
								"commandClass"
								value=
								"examples.FileUploadBean"
								/>
								<property
								name=
								"formView"
								value=
								"fileuploadform"
								/>
								<property
								name=
								"successView"
								value=
								"confirmation"
								/>
								</bean>

After that, create the controller and the actual class to hold the file property.

								public
								classFileUploadController
								extendsSimpleFormController {
								public
								voidonSubmitAction(ActionRequest request, ActionResponse response, Object command, BindException errors)
								throwsException {
								// cast the beanFileUploadBean bean = (FileUploadBean) command;
								// let's see if there's content there
								byte[] file = bean.getFile();
								if(file == null) {
								// hmm, that's strange, the user did not upload anything}
								// do something with the file here}
								protected
								voidinitBinder(PortletRequest request, PortletRequestDataBinder binder)
								throwsException {
								// to actually be able to convert Multipart instance to byte[]
								// we have to register a custom editorbinder.registerCustomEditor(
								byte[].
								class,
								newByteArrayMultipartFileEditor());
								// now Spring knows how to handle multipart object and convert} }
								public
								classFileUploadBean {
								private
								byte[] file;
								public
								voidsetFile(
								byte[] file) {
								this.file = file; }
								public
								byte[] getFile() {
								returnfile; } }

As you can see, the FileUploadBeanhas a property of type byte[]that holds the file. The controller registers a custom editor to let Spring know how to actually convert the multipart objects the resolver has found to properties specified by the bean. In this example, nothing is done with the byte[]property of the bean itself, but in practice you can do whatever you want (save it in a database, mail it to somebody, etc).

An equivalent example in which a file is bound straight to a String-typed property on a form backing object might look like this:

								public
								classFileUploadController
								extendsSimpleFormController {
								public
								voidonSubmitAction(ActionRequest request, ActionResponse response, Object command, BindException errors)
								throwsException {
								// cast the beanFileUploadBean bean = (FileUploadBean) command;
								// let's see if there's content thereString file = bean.getFile();
								if(file == null) {
								// hmm, that's strange, the user did not upload anything}
								// do something with the file here}
								protected
								voidinitBinder(PortletRequest request, PortletRequestDataBinder binder)
								throwsException {
								// to actually be able to convert Multipart instance to a String
								// we have to register a custom editorbinder.registerCustomEditor(String.
								class,
								newStringMultipartFileEditor());
								// now Spring knows how to handle multipart objects and convert} }
								public
								classFileUploadBean {
								privateString file;
								public
								voidsetFile(String file) {
								this.file = file; }
								publicString getFile() {
								returnfile; } }

Of course, this last example only makes (logical) sense in the context of uploading a plain text file (it wouldn’t work so well in the case of uploading an image file).

The third (and final) option is where one binds directly to a MultipartFileproperty declared on the (form backing) object’s class. In this case one does not need to register any custom property editor because there is no type conversion to be performed.

								public
								classFileUploadController
								extendsSimpleFormController {
								public
								voidonSubmitAction(ActionRequest request, ActionResponse response, Object command, BindException errors)
								throwsException {
								// cast the beanFileUploadBean bean = (FileUploadBean) command;
								// let's see if there's content thereMultipartFile file = bean.getFile();
								if(file == null) {
								// hmm, that's strange, the user did not upload anything}
								// do something with the file here} }
								public
								classFileUploadBean {
								privateMultipartFile file;
								public
								voidsetFile(MultipartFile file) {
								this.file = file; }
								publicMultipartFile getFile() {
								returnfile; } }

25.8 Handling exceptions

Just like Servlet MVC, Portlet MVC provides HandlerExceptionResolvers to ease the pain of unexpected exceptions that occur while your request is being processed by a handler that matched the request. Portlet MVC also provides a portlet-specific, concrete SimpleMappingExceptionResolverthat enables you to take the class name of any exception that might be thrown and map it to a view name.

25.9 Annotation-based controller configuration

Spring 2.5 introduced an annotation-based programming model for MVC controllers, using annotations such as @RequestMapping, @RequestParam, @ModelAttribute, etc. This annotation support is available for both Servlet MVC and Portlet MVC. Controllers implemented in this style do not have to extend specific base classes or implement specific interfaces. Furthermore, they do not usually have direct dependencies on Servlet or Portlet API’s, although they can easily get access to Servlet or Portlet facilities if desired.

The following sections document these annotations and how they are most commonly used in a Portlet environment.

25.9.1 Setting up the dispatcher for annotation support

`@RequestMapping` will only be processed if a corresponding HandlerMapping(for type level annotations) and/or HandlerAdapter(for method level annotations) is present in the dispatcher.This is the case by default in both DispatcherServletand DispatcherPortlet.

However, if you are defining custom HandlerMappingsor HandlerAdapters, then you need to make sure that a corresponding custom DefaultAnnotationHandlerMappingand/or AnnotationMethodHandlerAdapteris defined as well - provided that you intend to use @RequestMapping.

								<?xml version="1.0" encoding="UTF-8"?>
								<beans
								xmlns=
								"http://www.springframework.org/schema/beans"
								xmlns:xsi=
								"http://www.w3.org/2001/XMLSchema-instance"
								xsi:schemaLocation=
								"http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd"
								>
								<bean
								class=
								"org.springframework.web.portlet.mvc.annotation.DefaultAnnotationHandlerMapping"
								/>
								<bean
								class=
								"org.springframework.web.portlet.mvc.annotation.AnnotationMethodHandlerAdapter"
								/>// ... (controller bean definitions) ...
								</beans>

Defining a DefaultAnnotationHandlerMappingand/or AnnotationMethodHandlerAdapterexplicitly also makes sense if you would like to customize the mapping strategy, e.g. specifying a custom WebBindingInitializer(see below).

25.9.2 Defining a controller with @Controller

The @Controllerannotation indicates that a particular class serves the role of a controller. There is no need to extend any controller base class or reference the Portlet API. You are of course still able to reference Portlet-specific features if you need to.

The basic purpose of the @Controllerannotation is to act as a stereotype for the annotated class, indicating its role. The dispatcher will scan such annotated classes for mapped methods, detecting @RequestMappingannotations (see the next section).

Annotated controller beans may be defined explicitly, using a standard Spring bean definition in the dispatcher’s context. However, the @Controllerstereotype also allows for autodetection, aligned with Spring 2.5’s general support for detecting component classes in the classpath and auto-registering bean definitions for them.

To enable autodetection of such annotated controllers, you have to add component scanning to your configuration. This is easily achieved by using the spring-contextschema as shown in the following XML snippet:

								<?xml version="1.0" encoding="UTF-8"?>
								<beans
								xmlns=
								"http://www.springframework.org/schema/beans"
								xmlns:xsi=
								"http://www.w3.org/2001/XMLSchema-instance"
								xmlns:p=
								"http://www.springframework.org/schema/p"
								xmlns:context=
								"http://www.springframework.org/schema/context"
								xsi:schemaLocation=
								" http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd"
								>
								<context:component-scan
								base-package=
								"org.springframework.samples.petportal.portlet"
								/>// ...
								</beans>

25.9.3 Mapping requests with @RequestMapping

The @RequestMappingannotation is used to map portlet modes like 'VIEW'/'EDIT' onto an entire class or a particular handler method. Typically the type-level annotation maps a specific mode (or mode plus parameter condition) onto a form controller, with additional method-level annotations 'narrowing' the primary mapping for specific portlet request parameters.

[Tip] Tip

@RequestMappingat the type level may be used for plain implementations of the Controllerinterface as well. In this case, the request processing code would follow the traditional handle(Action|Render)Requestsignature, while the controller’s mapping would be expressed through an @RequestMappingannotation. This works for pre-built Controllerbase classes, such as SimpleFormController, too.

In the following discussion, we’ll focus on controllers that are based on annotated handler methods.

The following is an example of a form controller from the PetPortal sample application using this annotation:

								
									@Controller
								
									@RequestMapping("EDIT")
								
									@SessionAttributes("site")
								public
								classPetSitesEditController {
								privateProperties petSites;
								public
								voidsetPetSites(Properties petSites) {
								this.petSites = petSites; }
								
									@ModelAttribute("petSites")
								publicProperties getPetSites() {
								return
								this.petSites; }
								
									@RequestMapping
								// default (action=list)
								publicString showPetSites() {
								return
								"petSitesEdit"; }
								
									@RequestMapping(params = "action=add")
								// render phase
								publicString showSiteForm(Model model) {
								// Used for the initial form as well as for redisplaying with errors.
								if(!model.containsAttribute(
								"site")) { model.addAttribute(
								"site",
								newPetSite()); }
								return
								"petSitesAdd"; }
								
									@RequestMapping(params = "action=add")
								// action phase
								public
								voidpopulateSite(
								
									@ModelAttribute("site")PetSite petSite, BindingResult result, SessionStatus status, ActionResponse response) {
								newPetSiteValidator().validate(petSite, result);
								if(!result.hasErrors()) {
								this.petSites.put(petSite.getName(), petSite.getUrl()); status.setComplete(); response.setRenderParameter(
								"action",
								"list"); } }
								
									@RequestMapping(params = "action=delete")
								public
								voidremoveSite(
								
									@RequestParam("site")String site, ActionResponse response) {
								this.petSites.remove(site); response.setRenderParameter(
								"action",
								"list"); } }

As of Spring 3.0, there are dedicated @ActionMappingand @RenderMapping(as well as @ResourceMappingand @EventMapping) annotations which can be used instead:

								
									@Controller
								
									@RequestMapping("EDIT")
								
									@SessionAttributes("site")
								public
								classPetSitesEditController {
								privateProperties petSites;
								public
								voidsetPetSites(Properties petSites) {
								this.petSites = petSites; }
								
									@ModelAttribute("petSites")
								publicProperties getPetSites() {
								return
								this.petSites; }
								
									@RenderMapping
								// default (action=list)
								publicString showPetSites() {
								return
								"petSitesEdit"; }
								
									@RenderMapping(params = "action=add")
								publicString showSiteForm(Model model) {
								// Used for the initial form as well as for redisplaying with errors.
								if(!model.containsAttribute(
								"site")) { model.addAttribute(
								"site",
								newPetSite()); }
								return
								"petSitesAdd"; }
								
									@ActionMapping(params = "action=add")
								public
								voidpopulateSite(
								
									@ModelAttribute("site")PetSite petSite, BindingResult result, SessionStatus status, ActionResponse response) {
								newPetSiteValidator().validate(petSite, result);
								if(!result.hasErrors()) {
								this.petSites.put(petSite.getName(), petSite.getUrl()); status.setComplete(); response.setRenderParameter(
								"action",
								"list"); } }
								
									@ActionMapping(params = "action=delete")
								public
								voidremoveSite(
								
									@RequestParam("site")String site, ActionResponse response) {
								this.petSites.remove(site); response.setRenderParameter(
								"action",
								"list"); } }

25.9.4 Supported handler method arguments

Handler methods which are annotated with @RequestMappingare allowed to have very flexible signatures. They may have arguments of the following types, in arbitrary order (except for validation results, which need to follow right after the corresponding command object, if desired):

  • Request and/or response objects (Portlet API). You may choose any specific request/response type, e.g. PortletRequest / ActionRequest / RenderRequest. An explicitly declared action/render argument is also used for mapping specific request types onto a handler method (in case of no other information given that differentiates between action and render requests).
  • Session object (Portlet API): of type PortletSession. An argument of this type will enforce the presence of a corresponding session. As a consequence, such an argument will never be null.
  • org.springframework.web.context.request.WebRequestor org.springframework.web.context.request.NativeWebRequest. Allows for generic request parameter access as well as request/session attribute access, without ties to the native Servlet/Portlet API.
  • java.util.Localefor the current request locale (the portal locale in a Portlet environment).
  • java.util.TimeZone/ java.time.ZoneIdfor the current request time zone.
  • java.io.InputStream/ java.io.Readerfor access to the request’s content. This will be the raw InputStream/Reader as exposed by the Portlet API.
  • java.io.OutputStream/ java.io.Writerfor generating the response’s content. This will be the raw OutputStream/Writer as exposed by the Portlet API.
  • @RequestParamannotated parameters for access to specific Portlet request parameters. Parameter values will be converted to the declared method argument type.
  • java.util.Map/ org.springframework.ui.Model/ org.springframework.ui.ModelMapfor enriching the implicit model that will be exposed to the web view.
  • Command/form objects to bind parameters to: as bean properties or fields, with customizable type conversion, depending on @InitBindermethods and/or the HandlerAdapter configuration - see the " webBindingInitializer`" property on `AnnotationMethodHandlerAdapter. Such command objects along with their validation results will be exposed as model attributes, by default using the non-qualified command class name in property notation (e.g. "orderAddress" for type "mypackage.OrderAddress"). Specify a parameter-level ModelAttributeannotation for declaring a specific model attribute name.
  • org.springframework.validation.Errors/ org.springframework.validation.BindingResultvalidation results for a preceding command/form object (the immediate preceding argument).
  • org.springframework.web.bind.support.SessionStatusstatus handle for marking form processing as complete (triggering the cleanup of session attributes that have been indicated by the @SessionAttributesannotation at the handler type level).

The following return types are supported for handler methods:

  • A ModelAndViewobject, with the model implicitly enriched with command objects and the results of @ModelAttributeannotated reference data accessor methods.
  • A Modelobject, with the view name implicitly determined through a RequestToViewNameTranslatorand the model implicitly enriched with command objects and the results of @ModelAttributeannotated reference data accessor methods.
  • A Mapobject for exposing a model, with the view name implicitly determined through a RequestToViewNameTranslatorand the model implicitly enriched with command objects and the results of @ModelAttributeannotated reference data accessor methods.
  • A Viewobject, with the model implicitly determined through command objects and @ModelAttributeannotated reference data accessor methods. The handler method may also programmatically enrich the model by declaring a Modelargument (see above).
  • A Stringvalue which is interpreted as view name, with the model implicitly determined through command objects and @ModelAttributeannotated reference data accessor methods. The handler method may also programmatically enrich the model by declaring a Modelargument (see above).
  • voidif the method handles the response itself (e.g. by writing the response content directly).
  • Any other return type will be considered a single model attribute to be exposed to the view, using the attribute name specified through @ModelAttributeat the method level (or the default attribute name based on the return type’s class name otherwise). The model will be implicitly enriched with command objects and the results of @ModelAttributeannotated reference data accessor methods.

25.9.5 Binding request parameters to method parameters with @RequestParam

The @RequestParamannotation is used to bind request parameters to a method parameter in your controller.

The following code snippet from the PetPortal sample application shows the usage:

								
									@Controller
								
									@RequestMapping("EDIT")
								
									@SessionAttributes("site")
								public
								classPetSitesEditController {
								// ...
								public
								voidremoveSite(
								
									@RequestParam("site")String site, ActionResponse response) {
								this.petSites.remove(site); response.setRenderParameter(
								"action",
								"list"); }
								// ...}

Parameters using this annotation are required by default, but you can specify that a parameter is optional by setting @RequestParam’s `requiredattribute to false(e.g., @RequestParam(name="id", required=false)).

25.9.6 Providing a link to data from the model with @ModelAttribute

@ModelAttributehas two usage scenarios in controllers. When placed on a method parameter, @ModelAttributeis used to map a model attribute to the specific, annotated method parameter (see the populateSite()method below). This is how the controller gets a reference to the object holding the data entered in the form. In addition, the parameter can be declared as the specific type of the form backing object rather than as a generic java.lang.Object, thus increasing type safety.

@ModelAttributeis also used at the method level to provide reference datafor the model (see the getPetSites()method below). For this usage the method signature can contain the same types as documented above for the @RequestMappingannotation.

[Note] Note

@ModelAttributeannotated methods will be executed beforethe chosen @RequestMappingannotated handler method. They effectively pre-populate the implicit model with specific attributes, often loaded from a database. Such an attribute can then already be accessed through @ModelAttributeannotated handler method parameters in the chosen handler method, potentially with binding and validation applied to it.

The following code snippet shows these two usages of this annotation:

								
									@Controller
								
									@RequestMapping("EDIT")
								
									@SessionAttributes("site")
								public
								classPetSitesEditController {
								// ...
								
									@ModelAttribute("petSites")
								publicProperties getPetSites() {
								return
								this.petSites; }
								
									@RequestMapping(params = "action=add")
								// action phase
								public
								voidpopulateSite(
								
									@ModelAttribute("site")PetSite petSite, BindingResult result, SessionStatus status, ActionResponse response) {
								newPetSiteValidator().validate(petSite, result);
								if(!result.hasErrors()) {
								this.petSites.put(petSite.getName(), petSite.getUrl()); status.setComplete(); response.setRenderParameter(
								"action",
								"list"); } } }

25.9.7 Specifying attributes to store in a Session with @SessionAttributes

The type-level @SessionAttributesannotation declares session attributes used by a specific handler. This will typically list the names of model attributes or types of model attributes which should be transparently stored in the session or some conversational storage, serving as form-backing beans between subsequent requests.

The following code snippet shows the usage of this annotation:

								
									@Controller
								
									@RequestMapping("EDIT")
								
									@SessionAttributes("site")
								public
								classPetSitesEditController {
								// ...}

25.9.8 Customizing WebDataBinder initialization

To customize request parameter binding with PropertyEditors, etc. via Spring’s WebDataBinder, you can either use @InitBinder-annotated methods within your controller or externalize your configuration by providing a custom WebBindingInitializer.

Customizing data binding with @InitBinder

Annotating controller methods with @InitBinderallows you to configure web data binding directly within your controller class. @InitBinderidentifies methods which initialize the WebDataBinderwhich will be used for populating command and form object arguments of annotated handler methods.

Such init-binder methods support all arguments that @RequestMappingsupports, except for command/form objects and corresponding validation result objects. Init-binder methods must not have a return value. Thus, they are usually declared as void. Typical arguments include WebDataBinderin combination with WebRequestor java.util.Locale, allowing code to register context-specific editors.

The following example demonstrates the use of @InitBinderfor configuring a CustomDateEditorfor all java.util.Dateform properties.

									
										@Controller
									public
									classMyFormController {
									
										@InitBinder
									protected
									voidinitBinder(WebDataBinder binder) { SimpleDateFormat dateFormat =
									newSimpleDateFormat(
									"yyyy-MM-dd"); dateFormat.setLenient(false); binder.registerCustomEditor(Date.
									class,
									newCustomDateEditor(dateFormat, false)); }
									// ...}

Configuring a custom WebBindingInitializer

To externalize data binding initialization, you can provide a custom implementation of the WebBindingInitializerinterface, which you then enable by supplying a custom bean configuration for an AnnotationMethodHandlerAdapter, thus overriding the default configuration.

25.10 Portlet application deployment

The process of deploying a Spring Portlet MVC application is no different than deploying any JSR-286 Portlet application. However, this area is confusing enough in general that it is worth talking about here briefly.

Generally, the portal/portlet container runs in one webapp in your servlet container and your portlets run in another webapp in your servlet container. In order for the portlet container webapp to make calls into your portlet webapp it must make cross-context calls to a well-known servlet that provides access to the portlet services defined in your portlet.xmlfile.

The JSR-286 specification does not specify exactly how this should happen, so each portlet container has its own mechanism for this, which usually involves some kind of "deployment process" that makes changes to the portlet webapp itself and then registers the portlets within the portlet container.

At a minimum, the web.xmlfile in your portlet webapp is modified to inject the well-known servlet that the portlet container will call. In some cases a single servlet will service all portlets in the webapp, in other cases there will be an instance of the servlet for each portlet.

Some portlet containers will also inject libraries and/or configuration files into the webapp as well. The portlet container must also make its implementation of the Portlet JSP Tag Library available to your webapp.

The bottom line is that it is important to understand the deployment needs of your target portal and make sure they are met (usually by following the automated deployment process it provides). Be sure to carefully review the documentation from your portal for this process.

Once you have deployed your portlet, review the resulting web.xmlfile for sanity. Some older portals have been known to corrupt the definition of the ViewRendererServlet, thus breaking the rendering of your portlets.

26. WebSocket Support

This part of the reference documentation covers Spring Framework’s support for WebSocket-style messaging in web applications including use of STOMP as an application level WebSocket sub-protocol.

Section 26.1, “Introduction”establishes a frame of mind in which to think about WebSocket, covering adoption challenges, design considerations, and thoughts on when it is a good fit.

Section 26.2, “WebSocket API”reviews the Spring WebSocket API on the server-side, while Section 26.3, “SockJS Fallback Options”explains the SockJS protocol and shows how to configure and use it.

Section 26.4.1, “Overview of STOMP”introduces the STOMP messaging protocol. Section 26.4.2, “Enable STOMP over WebSocket”demonstrates how to configure STOMP support in Spring. Section 26.4.4, “Annotation Message Handling”and the following sections explain how to write annotated message handling methods, send messages, choose message broker options, as well as work with the special "user" destinations. Finally, Section 26.4.17, “Testing Annotated Controller Methods”lists three approaches to testing STOMP/WebSocket applications.

26.1 Introduction

The WebSocket protocol RFC 6455defines an important new capability for web applications: full-duplex, two-way communication between client and server. It is an exciting new capability on the heels of a long history of techniques to make the web more interactive including Java Applets, XMLHttpRequest, Adobe Flash, ActiveXObject, various Comet techniques, server-sent events, and others.

A proper introduction to the WebSocket protocol is beyond the scope of this document. At a minimum however it’s important to understand that HTTP is used only for the initial handshake, which relies on a mechanism built into HTTP to request a protocol upgrade (or in this case a protocol switch) to which the server can respond with HTTP status 101 (switching protocols) if it agrees. Assuming the handshake succeeds the TCP socket underlying the HTTP upgrade request remains open and both client and server can use it to send messages to each other.

Spring Framework 4 includes a new spring-websocketmodule with comprehensive WebSocket support. It is compatible with the Java WebSocket API standard ( JSR-356) and also provides additional value-add as explained in the rest of the introduction.

26.1.1 WebSocket Fallback Options

An important challenge to adoption is the lack of support for WebSocket in some browsers. Notably the first Internet Explorer version to support WebSocket is version 10 (see http://caniuse.com/websocketsfor support by browser versions). Furthermore, some restrictive proxies may be configured in ways that either preclude the attempt to do an HTTP upgrade or otherwise break connection after some time because it has remained opened for too long. A good overview on this topic from Peter Lubbers is available in the InfoQ article "How HTML5 Web Sockets Interact With Proxy Servers".

Therefore to build a WebSocket application today, fallback options are required in order to simulate the WebSocket API where necessary. The Spring Framework provides such transparent fallback options based on the SockJS protocol. These options can be enabled through configuration and do not require modifying the application otherwise.

26.1.2 A Messaging Architecture

Aside from short-to-midterm adoption challenges, using WebSocket brings up important design considerations that are important to recognize early on, especially in contrast to what we know about building web applications today.

Today REST is a widely accepted, understood, and supported architecture for building web applications. It is an architecture that relies on having many URLs ( nouns), a handful of HTTP methods ( verbs), and other principles such as using hypermedia ( links), remaining stateless, etc.

By contrast a WebSocket application may use a single URL only for the initial HTTP handshake. All messages thereafter share and flow on the same TCP connection. This points to an entirely different, asynchronous, event-driven, messaging architecture. One that is much closer to traditional messaging applications (e.g. JMS, AMQP).

Spring Framework 4 includes a new spring-messagingmodule with key abstractions from the Spring Integrationproject such as Message, MessageChannel, MessageHandler, and others that can serve as a foundation for such a messaging architecture. The module also includes a set of annotations for mapping messages to methods, similar to the Spring MVC annotation based programming model.

26.1.3 Sub-Protocol Support in WebSocket

WebSocket does imply a messaging architecturebut does not mandate the use of any specific messaging protocol. It is a very thin layer over TCP that transforms a stream of bytes into a stream of messages (either text or binary) and not much more. It is up to applications to interpret the meaning of a message.

Unlike HTTP, which is an application-level protocol, in the WebSocket protocol there is simply not enough information in an incoming message for a framework or container to know how to route it or process it. Therefore WebSocket is arguably too low level for anything but a very trivial application. It can be done, but it will likely lead to creating a framework on top. This is comparable to how most web applications today are written using a web framework rather than the Servlet API alone.

For this reason the WebSocket RFC defines the use of sub-protocols. During the handshake, the client and server can use the header Sec-WebSocket-Protocolto agree on a sub-protocol, i.e. a higher, application-level protocol to use. The use of a sub-protocol is not required, but even if not used, applications will still need to choose a message format that both the client and server can understand. That format can be custom, framework-specific, or a standard messaging protocol.

The Spring Framework provides support for using STOMP — a simple, messaging protocol originally created for use in scripting languages with frames inspired by HTTP. STOMP is widely supported and well suited for use over WebSocket and over the web.

26.1.4 Should I Use WebSocket?

With all the design considerations surrounding the use of WebSocket, it is reasonable to ask, "When is it appropriate to use?".

The best fit for WebSocket is in web applications where the client and server need to exchange events at high frequency and with low latency. Prime candidates include, but are not limited to, applications in finance, games, collaboration, and others. Such applications are both very sensitive to time delays and also need to exchange a wide variety of messages at a high frequency.

For other application types, however, this may not be the case. For example, a news or social feed that shows breaking news as it becomes available may be perfectly okay with simple polling once every few minutes. Here latency is important, but it is acceptable if the news takes a few minutes to appear.

Even in cases where latency is crucial, if the volume of messages is relatively low (e.g. monitoring network failures) the use of long pollingshould be considered as a relatively simple alternative that works reliably and is comparable in terms of efficiency (again assuming the volume of messages is relatively low).

It is the combination of both low latency and high frequency of messages that can make the use of the WebSocket protocol critical. Even in such applications, the choice remains whether all client-server communication should be done through WebSocket messages as opposed to using HTTP and REST. The answer is going to vary by application; however, it is likely that some functionality may be exposed over both WebSocket and as a REST API in order to provide clients with alternatives. Furthermore, a REST API call may need to broadcast a message to interested clients connected via WebSocket.

The Spring Framework allows @Controllerand @RestControllerclasses to have both HTTP request handling and WebSocket message handling methods. Furthermore, a Spring MVC request handling method, or any application method for that matter, can easily broadcast a message to all interested WebSocket clients or to a specific user.

26.2 WebSocket API

The Spring Framework provides a WebSocket API designed to adapt to various WebSocket engines. Currently the list includes WebSocket runtimes such as Tomcat 7.0.47+, Jetty 9.1+, GlassFish 4.1+, WebLogic 12.1.3+, and Undertow 1.0+ (and WildFly 8.0+). Additional support may be added as more WebSocket runtimes become available.

[Note] Note

As explained in the introduction, direct use of a WebSocket API is too low level for applications — until assumptions are made about the format of a message there is little a framework can do to interpret messages or route them via annotations. This is why applications should consider using a sub-protocol and Spring’s STOMP over WebSocketsupport.

When using a higher level protocol, the details of the WebSocket API become less relevant, much like the details of TCP communication are not exposed to applications when using HTTP. Nevertheless this section covers the details of using WebSocket directly.

26.2.1 Create and Configure a WebSocketHandler

Creating a WebSocket server is as simple as implementing WebSocketHandleror more likely extending either TextWebSocketHandleror BinaryWebSocketHandler:

								importorg.springframework.web.socket.WebSocketHandler;
								importorg.springframework.web.socket.WebSocketSession;
								importorg.springframework.web.socket.TextMessage;
								public
								classMyHandler
								extendsTextWebSocketHandler {
								
									@Override
								public
								voidhandleTextMessage(WebSocketSession session, TextMessage message) {
								// ...} }

There is dedicated WebSocket Java-config and XML namespace support for mapping the above WebSocket handler to a specific URL:

								importorg.springframework.web.socket.config.annotation.EnableWebSocket;
								importorg.springframework.web.socket.config.annotation.WebSocketConfigurer;
								importorg.springframework.web.socket.config.annotation.WebSocketHandlerRegistry;
								
									@Configuration
								
									@EnableWebSocket
								public
								classWebSocketConfig
								implementsWebSocketConfigurer {
								
									@Override
								public
								voidregisterWebSocketHandlers(WebSocketHandlerRegistry registry) { registry.addHandler(myHandler(),
								"/myHandler"); }
								
									@Bean
								publicWebSocketHandler myHandler() {
								return
								newMyHandler(); } }

XML configuration equivalent:

								<beans
								xmlns=
								"http://www.springframework.org/schema/beans"
								xmlns:xsi=
								"http://www.w3.org/2001/XMLSchema-instance"
								xmlns:websocket=
								"http://www.springframework.org/schema/websocket"
								xsi:schemaLocation=
								" http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/websocket http://www.springframework.org/schema/websocket/spring-websocket.xsd"
								>
								<websocket:handlers>
								<websocket:mapping
								path=
								"/myHandler"
								handler=
								"myHandler"
								/>
								</websocket:handlers>
								<bean
								id=
								"myHandler"
								class=
								"org.springframework.samples.MyHandler"
								/>
								</beans>

The above is for use in Spring MVC applications and should be included in the configuration of a DispatcherServlet. However, Spring’s WebSocket support does not depend on Spring MVC. It is relatively simple to integrate a WebSocketHandlerinto other HTTP serving environments with the help of WebSocketHttpRequestHandler.

26.2.2 Customizing the WebSocket Handshake

The easiest way to customize the initial HTTP WebSocket handshake request is through a HandshakeInterceptor, which exposes "before" and "after" the handshake methods. Such an interceptor can be used to preclude the handshake or to make any attributes available to the WebSocketSession. For example, there is a built-in interceptor for passing HTTP session attributes to the WebSocket session:

								
									@Configuration
								
									@EnableWebSocket
								public
								classWebSocketConfig
								implementsWebSocketConfigurer {
								
									@Override
								public
								voidregisterWebSocketHandlers(WebSocketHandlerRegistry registry) { registry.addHandler(
								newMyHandler(),
								"/myHandler") .addInterceptors(
								newHttpSessionHandshakeInterceptor()); } }

And the XML configuration equivalent:

								<beans
								xmlns=
								"http://www.springframework.org/schema/beans"
								xmlns:xsi=
								"http://www.w3.org/2001/XMLSchema-instance"
								xmlns:websocket=
								"http://www.springframework.org/schema/websocket"
								xsi:schemaLocation=
								" http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/websocket http://www.springframework.org/schema/websocket/spring-websocket.xsd"
								>
								<websocket:handlers>
								<websocket:mapping
								path=
								"/myHandler"
								handler=
								"myHandler"
								/>
								<websocket:handshake-interceptors>
								<bean
								class=
								"org.springframework.web.socket.server.support.HttpSessionHandshakeInterceptor"
								/>
								</websocket:handshake-interceptors>
								</websocket:handlers>
								<bean
								id=
								"myHandler"
								class=
								"org.springframework.samples.MyHandler"
								/>
								</beans>

A more advanced option is to extend the DefaultHandshakeHandlerthat performs the steps of the WebSocket handshake, including validating the client origin, negotiating a sub-protocol, and others. An application may also need to use this option if it needs to configure a custom RequestUpgradeStrategyin order to adapt to a WebSocket server engine and version that is not yet supported (also see Section 26.2.4, “Deployment Considerations”for more on this subject). Both the Java-config and XML namespace make it possible to configure a custom HandshakeHandler.

26.2.3 WebSocketHandler Decoration

Spring provides a WebSocketHandlerDecoratorbase class that can be used to decorate a WebSocketHandlerwith additional behavior. Logging and exception handling implementations are provided and added by default when using the WebSocket Java-config or XML namespace. The ExceptionWebSocketHandlerDecoratorcatches all uncaught exceptions arising from any WebSocketHandler method and closes the WebSocket session with status 1011that indicates a server error.

26.2.4 Deployment Considerations

The Spring WebSocket API is easy to integrate into a Spring MVC application where the DispatcherServletserves both HTTP WebSocket handshake as well as other HTTP requests. It is also easy to integrate into other HTTP processing scenarios by invoking WebSocketHttpRequestHandler. This is convenient and easy to understand. However, special considerations apply with regards to JSR-356 runtimes.

The Java WebSocket API (JSR-356) provides two deployment mechanisms. The first involves a Servlet container classpath scan (Servlet 3 feature) at startup; and the other is a registration API to use at Servlet container initialization. Neither of these mechanism makes it possible to use a single "front controller" for all HTTP processing — including WebSocket handshake and all other HTTP requests — such as Spring MVC’s DispatcherServlet.

This is a significant limitation of JSR-356 that Spring’s WebSocket support addresses by providing a server-specific RequestUpgradeStrategyeven when running in a JSR-356 runtime.

[Note] Note

A request to overcome the above limitation in the Java WebSocket API has been created and can be followed at WEBSOCKET_SPEC-211. Also note that Tomcat and Jetty already provide native API alternatives that makes it easy to overcome the limitation. We are hopeful that more servers will follow their example regardless of when it is addressed in the Java WebSocket API.

A secondary consideration is that Servlet containers with JSR-356 support are expected to perform a ServletContainerInitializer(SCI) scan that can slow down application startup, in some cases dramatically. If a significant impact is observed after an upgrade to a Servlet container version with JSR-356 support, it should be possible to selectively enable or disable web fragments (and SCI scanning) through the use of the <absolute-ordering />element in web.xml:

								<web-app
								xmlns=
								"http://java.sun.com/xml/ns/javaee"
								xmlns:xsi=
								"http://www.w3.org/2001/XMLSchema-instance"
								xsi:schemaLocation=
								" http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"
								version=
								"3.0"
								>
								<absolute-ordering/>
								</web-app>

You can then selectively enable web fragments by name, such as Spring’s own SpringServletContainerInitializerthat provides support for the Servlet 3 Java initialization API, if required:

								<web-app
								xmlns=
								"http://java.sun.com/xml/ns/javaee"
								xmlns:xsi=
								"http://www.w3.org/2001/XMLSchema-instance"
								xsi:schemaLocation=
								" http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"
								version=
								"3.0"
								>
								<absolute-ordering>
								<name>spring_web
								</name>
								</absolute-ordering>
								</web-app>

26.2.5 Configuring the WebSocket Engine

Each underlying WebSocket engine exposes configuration properties that control runtime characteristics such as the size of message buffer sizes, idle timeout, and others.

For Tomcat, WildFly, and GlassFish add a ServletServerContainerFactoryBeanto your WebSocket Java config:

								
									@Configuration
								
									@EnableWebSocket
								public
								classWebSocketConfig
								implementsWebSocketConfigurer {
								
									@Bean
								publicServletServerContainerFactoryBean createWebSocketContainer() { ServletServerContainerFactoryBean container =
								newServletServerContainerFactoryBean(); container.setMaxTextMessageBufferSize(
								8192); container.setMaxBinaryMessageBufferSize(
								8192);
								returncontainer; } }

or WebSocket XML namespace:

								<beans
								xmlns=
								"http://www.springframework.org/schema/beans"
								xmlns:xsi=
								"http://www.w3.org/2001/XMLSchema-instance"
								xmlns:websocket=
								"http://www.springframework.org/schema/websocket"
								xsi:schemaLocation=
								" http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/websocket http://www.springframework.org/schema/websocket/spring-websocket.xsd"
								>
								<bean
								class=
								"org.springframework...ServletServerContainerFactoryBean"
								>
								<property
								name=
								"maxTextMessageBufferSize"
								value=
								"8192"
								/>
								<property
								name=
								"maxBinaryMessageBufferSize"
								value=
								"8192"
								/>
								</bean>
								</beans>
[Note] Note

For client side WebSocket configuration, you should use WebSocketContainerFactoryBean(XML) or ContainerProvider.getWebSocketContainer()(Java config).

For Jetty, you’ll need to supply a pre-configured Jetty WebSocketServerFactoryand plug that into Spring’s DefaultHandshakeHandlerthrough your WebSocket Java config:

								
									@Configuration
								
									@EnableWebSocket
								public
								classWebSocketConfig
								implementsWebSocketConfigurer {
								
									@Override
								public
								voidregisterWebSocketHandlers(WebSocketHandlerRegistry registry) { registry.addHandler(echoWebSocketHandler(),
								"/echo").setHandshakeHandler(handshakeHandler()); }
								
									@Bean
								publicDefaultHandshakeHandler handshakeHandler() { WebSocketPolicy policy =
								newWebSocketPolicy(WebSocketBehavior.SERVER); policy.setInputBufferSize(
								8192); policy.setIdleTimeout(
								600000);
								return
								newDefaultHandshakeHandler(
								newJettyRequestUpgradeStrategy(
								newWebSocketServerFactory(policy))); } }

or WebSocket XML namespace:

								<beans
								xmlns=
								"http://www.springframework.org/schema/beans"
								xmlns:xsi=
								"http://www.w3.org/2001/XMLSchema-instance"
								xmlns:websocket=
								"http://www.springframework.org/schema/websocket"
								xsi:schemaLocation=
								" http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/websocket http://www.springframework.org/schema/websocket/spring-websocket.xsd"
								>
								<websocket:handlers>
								<websocket:mapping
								path=
								"/echo"
								handler=
								"echoHandler"
								/>
								<websocket:handshake-handler
								ref=
								"handshakeHandler"
								/>
								</websocket:handlers>
								<bean
								id=
								"handshakeHandler"
								class=
								"org.springframework...DefaultHandshakeHandler"
								>
								<constructor-arg
								ref=
								"upgradeStrategy"
								/>
								</bean>
								<bean
								id=
								"upgradeStrategy"
								class=
								"org.springframework...JettyRequestUpgradeStrategy"
								>
								<constructor-arg
								ref=
								"serverFactory"
								/>
								</bean>
								<bean
								id=
								"serverFactory"
								class=
								"org.eclipse.jetty...WebSocketServerFactory"
								>
								<constructor-arg>
								<bean
								class=
								"org.eclipse.jetty...WebSocketPolicy"
								>
								<constructor-arg
								value=
								"SERVER"
								/>
								<property
								name=
								"inputBufferSize"
								value=
								"8092"
								/>
								<property
								name=
								"idleTimeout"
								value=
								"600000"
								/>
								</bean>
								</constructor-arg>
								</bean>
								</beans>

26.2.6 Configuring allowed origins

As of Spring Framework 4.1.5, the default behavior for WebSocket and SockJS is to accept only same originrequests. It is also possible to allow allor a specified list of origins. This check is mostly designed for browser clients. There is nothing preventing other types of clients from modifying the Originheader value (see RFC 6454: The Web Origin Conceptfor more details).

The 3 possible behaviors are:

  • Allow only same origin requests (default): in this mode, when SockJS is enabled, the Iframe HTTP response header X-Frame-Optionsis set to SAMEORIGIN, and JSONP transport is disabled since it does not allow to check the origin of a request. As a consequence, IE6 and IE7 are not supported when this mode is enabled.
  • Allow a specified list of origins: each provided allowed originmust start with http://or https://. In this mode, when SockJS is enabled, both IFrame and JSONP based transports are disabled. As a consequence, IE6 through IE9 are not supported when this mode is enabled.
  • Allow all origins: to enable this mode, you should provide *as the allowed origin value. In this mode, all transports are available.

WebSocket and SockJS allowed origins can be configured as shown bellow:

								importorg.springframework.web.socket.config.annotation.EnableWebSocket;
								importorg.springframework.web.socket.config.annotation.WebSocketConfigurer;
								importorg.springframework.web.socket.config.annotation.WebSocketHandlerRegistry;
								
									@Configuration
								
									@EnableWebSocket
								public
								classWebSocketConfig
								implementsWebSocketConfigurer {
								
									@Override
								public
								voidregisterWebSocketHandlers(WebSocketHandlerRegistry registry) { registry.addHandler(myHandler(),
								"/myHandler").setAllowedOrigins(
								"http://mydomain.com"); }
								
									@Bean
								publicWebSocketHandler myHandler() {
								return
								newMyHandler(); } }

XML configuration equivalent:

								<beans
								xmlns=
								"http://www.springframework.org/schema/beans"
								xmlns:xsi=
								"http://www.w3.org/2001/XMLSchema-instance"
								xmlns:websocket=
								"http://www.springframework.org/schema/websocket"
								xsi:schemaLocation=
								" http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/websocket http://www.springframework.org/schema/websocket/spring-websocket.xsd"
								>
								<websocket:handlers
								allowed-origins=
								"http://mydomain.com"
								>
								<websocket:mapping
								path=
								"/myHandler"
								handler=
								"myHandler"
								/>
								</websocket:handlers>
								<bean
								id=
								"myHandler"
								class=
								"org.springframework.samples.MyHandler"
								/>
								</beans>

26.3 SockJS Fallback Options

As explained in the introduction, WebSocket is not supported in all browsers yet and may be precluded by restrictive network proxies. This is why Spring provides fallback options that emulate the WebSocket API as close as possible based on the SockJS protocol(version 0.3.3).

26.3.1 Overview of SockJS

The goal of SockJS is to let applications use a WebSocket API but fall back to non-WebSocket alternatives when necessary at runtime, i.e. without the need to change application code.

SockJS consists of:

  • The SockJS protocoldefined in the form of executable narrated tests.
  • The SockJS JavaScript client- a client library for use in browsers.
  • SockJS server implementations including one in the Spring Framework spring-websocketmodule.
  • As of 4.1 spring-websocketalso provides a SockJS Java client.

SockJS is designed for use in browsers. It goes to great lengths to support a wide range of browser versions using a variety of techniques. For the full list of SockJS transport types and browsers see the SockJS clientpage. Transports fall in 3 general categories: WebSocket, HTTP Streaming, and HTTP Long Polling. For an overview of these categories see this blog post.

The SockJS client begins by sending "GET /info"to obtain basic information from the server. After that it must decide what transport to use. If possible WebSocket is used. If not, in most browsers there is at least one HTTP streaming option and if not then HTTP (long) polling is used.

All transport requests have the following URL structure:

http://host:port/myApp/myEndpoint/{server-id}/{session-id}/{transport}
  • {server-id}- useful for routing requests in a cluster but not used otherwise.
  • {session-id}- correlates HTTP requests belonging to a SockJS session.
  • {transport}- indicates the transport type, e.g. "websocket", "xhr-streaming", etc.

The WebSocket transport needs only a single HTTP request to do the WebSocket handshake. All messages thereafter are exchanged on that socket.

HTTP transports require more requests. Ajax/XHR streaming for example relies on one long-running request for server-to-client messages and additional HTTP POST requests for client-to-server messages. Long polling is similar except it ends the current request after each server-to-client send.

SockJS adds minimal message framing. For example the server sends the letter o ("open" frame) initially, messages are sent as a["message1","message2"] (JSON-encoded array), the letter h ("heartbeat" frame) if no messages flow for 25 seconds by default, and the letter c ("close" frame) to close the session.

To learn more, run an example in a browser and watch the HTTP requests. The SockJS client allows fixing the list of transports so it is possible to see each transport one at a time. The SockJS client also provides a debug flag which enables helpful messages in the browser console. On the server side enable TRACElogging for org.springframework.web.socket. For even more detail refer to the SockJS protocol narrated test.

26.3.2 Enable SockJS

SockJS is easy to enable through Java configuration:

								
									@Configuration
								
									@EnableWebSocket
								public
								classWebSocketConfig
								implementsWebSocketConfigurer {
								
									@Override
								public
								voidregisterWebSocketHandlers(WebSocketHandlerRegistry registry) { registry.addHandler(myHandler(),
								"/myHandler").withSockJS(); }
								
									@Bean
								publicWebSocketHandler myHandler() {
								return
								newMyHandler(); } }

and the XML configuration equivalent:

								<beans
								xmlns=
								"http://www.springframework.org/schema/beans"
								xmlns:xsi=
								"http://www.w3.org/2001/XMLSchema-instance"
								xmlns:websocket=
								"http://www.springframework.org/schema/websocket"
								xsi:schemaLocation=
								" http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/websocket http://www.springframework.org/schema/websocket/spring-websocket.xsd"
								>
								<websocket:handlers>
								<websocket:mapping
								path=
								"/myHandler"
								handler=
								"myHandler"
								/>
								<websocket:sockjs/>
								</websocket:handlers>
								<bean
								id=
								"myHandler"
								class=
								"org.springframework.samples.MyHandler"
								/>
								</beans>

The above is for use in Spring MVC applications and should be included in the configuration of a DispatcherServlet. However, Spring’s WebSocket and SockJS support does not depend on Spring MVC. It is relatively simple to integrate into other HTTP serving environments with the help of SockJsHttpRequestHandler.

On the browser side, applications can use the sockjs-client(version 1.0.x) that emulates the W3C WebSocket API and communicates with the server to select the best transport option depending on the browser it’s running in. Review the sockjs-clientpage and the list of transport types supported by browser. The client also provides several configuration options, for example, to specify which transports to include.

26.3.3 HTTP Streaming in IE 8, 9: Ajax/XHR vs IFrame

Internet Explorer 8 and 9 are and will remain common for some time. They are a key reason for having SockJS. This section covers important considerations about running in those browsers.

The SockJS client supports Ajax/XHR streaming in IE 8 and 9 via Microsoft’s XDomainRequest. That works across domains but does not support sending cookies. Cookies are very often essential for Java applications. However since the SockJS client can be used with many server types (not just Java ones), it needs to know whether cookies matter. If so the SockJS client prefers Ajax/XHR for streaming or otherwise it relies on a iframe-based technique.

The very first "/info"request from the SockJS client is a request for information that can influence the client’s choice of transports. One of those details is whether the server application relies on cookies, e.g. for authentication purposes or clustering with sticky sessions. Spring’s SockJS support includes a property called sessionCookieNeeded. It is enabled by default since most Java applications rely on the JSESSIONIDcookie. If your application does not need it, you can turn off this option and the SockJS client should choose xdr-streamingin IE 8 and 9.

If you do use an iframe-based transport, and in any case, it is good to know that browsers can be instructed to block the use of IFrames on a given page by setting the HTTP response header X-Frame-Optionsto DENY, SAMEORIGIN, or ALLOW-FROM <origin>. This is used to prevent clickjacking.

[Note] Note

Spring Security 3.2+ provides support for setting X-Frame-Optionson every response. By default the Spring Security Java config sets it to DENY. In 3.2 the Spring Security XML namespace does not set that header by default but may be configured to do so, and in the future it may set it by default.

See Section 7.1. "Default Security Headers"of the Spring Security documentation for details on how to configure the setting of the X-Frame-Optionsheader. You may also check or watch SEC-2501for additional background.

If your application adds the X-Frame-Optionsresponse header (as it should!) and relies on an iframe-based transport, you will need to set the header value to SAMEORIGINor ALLOW-FROM <origin>. Along with that the Spring SockJS support also needs to know the location of the SockJS client because it is loaded from the iframe. By default the iframe is set to download the SockJS client from a CDN location. It is a good idea to configure this option to a URL from the same origin as the application.

In Java config this can be done as shown below. The XML namespace provides a similar option via the <websocket:sockjs>element:

								
									@Configuration
								
									@EnableWebSocket
								public
								classWebSocketConfig
								implementsWebSocketConfigurer {
								
									@Override
								public
								voidregisterStompEndpoints(StompEndpointRegistry registry) { registry.addEndpoint(
								"/portfolio").withSockJS() .setClientLibraryUrl(
								"http://localhost:8080/myapp/js/sockjs-client.js"); }
								// ...}
[Note] Note

During initial development, do enable the SockJS client develmode that prevents the browser from caching SockJS requests (like the iframe) that would otherwise be cached. For details on how to enable it see the SockJS clientpage.

26.3.4 Heartbeat Messages

The SockJS protocol requires servers to send heartbeat messages to preclude proxies from concluding a connection is hung. The Spring SockJS configuration has a property called heartbeatTimethat can be used to customize the frequency. By default a heartbeat is sent after 25 seconds assuming no other messages were sent on that connection. This 25 seconds value is in line with the following IETF recommendationfor public Internet applications.

[Note] Note

When using STOMP over WebSocket/SockJS, if the STOMP client and server negotiate heartbeats to be exchanged, the SockJS heartbeats are disabled.

The Spring SockJS support also allows configuring the TaskSchedulerto use for scheduling heartbeats tasks. The task scheduler is backed by a thread pool with default settings based on the number of available processors. Applications should consider customizing the settings according to their specific needs.

26.3.5 Servlet 3 Async Requests

HTTP streaming and HTTP long polling SockJS transports require a connection to remain open longer than usual. For an overview of these techniques see this blog post.

In Servlet containers this is done through Servlet 3 async support that allows exiting the Servlet container thread processing a request and continuing to write to the response from another thread.

A specific issue is that the Servlet API does not provide notifications for a client that has gone away, see SERVLET_SPEC-44. However, Servlet containers raise an exception on subsequent attempts to write to the response. Since Spring’s SockJS Service supports sever-sent heartbeats (every 25 seconds by default), that means a client disconnect is usually detected within that time period or earlier if messages are sent more frequently.

[Note] Note

As a result network IO failures may occur simply because a client has disconnected, which can fill the log with unnecessary stack traces. Spring makes a best effort to identify such network failures that represent client disconnects (specific to each server) and log a minimal message using the dedicated log category DISCONNECTED_CLIENT_LOG_CATEGORYdefined in AbstractSockJsSession. If you need to see the stack traces, set that log category to TRACE.

26.3.6 CORS Headers for SockJS

If you allow cross-origin requests (see Section 26.2.6, “Configuring allowed origins”), the SockJS protocol uses CORS for cross-domain support in the XHR streaming and polling transports. Therefore CORS headers are added automatically unless the presence of CORS headers in the response is detected. So if an application is already configured to provide CORS support, e.g. through a Servlet Filter, Spring’s SockJsService will skip this part.

It is also possible to disable the addition of these CORS headers via the suppressCorsproperty in Spring’s SockJsService.

The following is the list of headers and values expected by SockJS:

  • "Access-Control-Allow-Origin"- initialized from the value of the "Origin" request header.
  • "Access-Control-Allow-Credentials"- always set to true.
  • "Access-Control-Request-Headers"- initialized from values from the equivalent request header.
  • "Access-Control-Allow-Methods"- the HTTP methods a transport supports (see TransportTypeenum).
  • "Access-Control-Max-Age"- set to 31536000 (1 year).

For the exact implementation see addCorsHeadersin AbstractSockJsServiceas well as the TransportTypeenum in the source code.

Alternatively if the CORS configuration allows it consider excluding URLs with the SockJS endpoint prefix thus letting Spring’s SockJsServicehandle it.

26.3.7 SockJS Client

A SockJS Java client is provided in order to connect to remote SockJS endpoints without using a browser. This can be especially useful when there is a need for bidirectional communication between 2 servers over a public network, i.e. where network proxies may preclude the use of the WebSocket protocol. A SockJS Java client is also very useful for testing purposes, for example to simulate a large number of concurrent users.

The SockJS Java client supports the "websocket", "xhr-streaming", and "xhr-polling" transports. The remaining ones only make sense for use in a browser.

The WebSocketTransportcan be configured with:

  • StandardWebSocketClientin a JSR-356 runtime
  • JettyWebSocketClientusing the Jetty 9+ native WebSocket API
  • Any implementation of Spring’s WebSocketClient

An XhrTransportby definition supports both "xhr-streaming" and "xhr-polling" since from a client perspective there is no difference other than in the URL used to connect to the server. At present there are two implementations:

  • RestTemplateXhrTransportuses Spring’s RestTemplatefor HTTP requests.
  • JettyXhrTransportuses Jetty’s HttpClientfor HTTP requests.

The example below shows how to create a SockJS client and connect to a SockJS endpoint:

List<Transport> transports =
								newArrayList<>(
								2); transports.add(
								newWebSocketTransport(
								newStandardWebSocketClient())); transports.add(
								newRestTemplateXhrTransport()); SockJsClient sockJsClient =
								newSockJsClient(transports); sockJsClient.doHandshake(
								newMyWebSocketHandler(),
								"ws://example.com:8080/sockjs");
[Note] Note

SockJS uses JSON formatted arrays for messages. By default Jackson 2 is used and needs to be on the classpath. Alternatively you can configure a custom implementation of SockJsMessageCodecand configure it on the SockJsClient.

To use the SockJsClient for simulating a large number of concurrent users you will need to configure the underlying HTTP client (for XHR transports) to allow a sufficient number of connections and threads. For example with Jetty:

HttpClient jettyHttpClient =
								newHttpClient(); jettyHttpClient.setMaxConnectionsPerDestination(
								1000); jettyHttpClient.setExecutor(
								newQueuedThreadPool(
								1000));

Consider also customizing these server-side SockJS related properties (see Javadoc for details):

								
									@Configuration
								public
								classWebSocketConfig
								extendsWebSocketMessageBrokerConfigurationSupport {
								
									@Override
								public
								voidregisterStompEndpoints(StompEndpointRegistry registry) { registry.addEndpoint(
								"/sockjs").withSockJS() .setStreamBytesLimit(
								512*
								1024) .setHttpMessageCacheSize(
								1000) .setDisconnectDelay(
								30*
								1000); }
								// ...}

26.4 STOMP Over WebSocket Messaging Architecture

The WebSocket protocol defines two types of messages, text and binary, but their content is undefined. It’s expected that the client and server may agree on using a sub-protocol (i.e. a higher-level protocol) to define message semantics. While the use of a sub-protocol with WebSocket is completely optional either way client and server will need to agree on some kind of protocol to help interpret messages.

26.4.1 Overview of STOMP

STOMPis a simple text-oriented messaging protocol that was originally created for scripting languages such as Ruby, Python, and Perl to connect to enterprise message brokers. It is designed to address a subset of commonly used messaging patterns. STOMP can be used over any reliable 2-way streaming network protocol such as TCP and WebSocket. Although STOMP is a text-oriented protocol, the payload of messages can be either text or binary.

STOMP is a frame based protocol whose frames are modeled on HTTP. The structure of a STOMP frame:

COMMAND header1:value1 header2:value2 Body^@

Clients can use the SEND or SUBSCRIBE commands to send or subscribe for messages along with a "destination" header that describes what the message is about and who should receive it. This enables a simple publish-subscribe mechanism that can be used to send messages through the broker to other connected clients or to send messages to the server to request that some work be performed.

When using Spring’s STOMP support, the Spring WebSocket application acts as the STOMP broker to clients. Messages are routed to @Controllermessage-handling methods or to a simple, in-memory broker that keeps track of subscriptions and broadcasts messages to subscribed users. You can also configure Spring to work with a dedicated STOMP broker (e.g. RabbitMQ, ActiveMQ, etc) for the actual broadcasting of messages. In that case Spring maintains TCP connections to the broker, relays messages to it, and also passes messages from it down to connected WebSocket clients. Thus Spring web applications can rely on unified HTTP-based security, common validation, and a familiar programming model message-handling work.

Here is an example of a client subscribing to receive stock quotes which the server may emit periodically e.g. via a scheduled task sending messages through a SimpMessagingTemplateto the broker:

SUBSCRIBE id:sub-1 destination:/topic/price.stock.* ^@

Here is an example of a client sending a trade request, which the server may handle through an @MessageMappingmethod and later on, after the execution, broadcast a trade confirmation message and details down to the client:

SEND destination:/queue/trade content-type:application/json content-length:44 {"action":"BUY","ticker":"MMM","shares",44}^@

The meaning of a destination is intentionally left opaque in the STOMP spec. It can be any string, and it’s entirely up to STOMP servers to define the semantics and the syntax of the destinations that they support. It is very common, however, for destinations to be path-like strings where "/topic/.."implies publish-subscribe ( one-to-many) and "/queue/"implies point-to-point ( one-to-one) message exchanges.

STOMP servers can use the MESSAGE command to broadcast messages to all subscribers. Here is an example of a server sending a stock quote to a subscribed client:

MESSAGE message-id:nxahklf6-1 subscription:sub-1 destination:/topic/price.stock.MMM {"ticker":"MMM","price":129.45}^@

It is important to know that a server cannot send unsolicited messages. All messages from a server must be in response to a specific client subscription, and the "subscription-id" header of the server message must match the "id" header of the client subscription.

The above overview is intended to provide the most basic understanding of the STOMP protocol. It is recommended to review the protocol specificationin full.

The benefits of using STOMP as a WebSocket sub-protocol:

  • No need to invent a custom message format
  • Use existing stomp.jsclient in the browser
  • Ability to route messages to based on destination
  • Option to use full-fledged message broker such as RabbitMQ, ActiveMQ, etc. for broadcasting

Most importantly the use of STOMP (vs plain WebSocket) enables the Spring Framework to provide a programming model for application-level use in the same way that Spring MVC provides a programming model based on HTTP.

26.4.2 Enable STOMP over WebSocket

The Spring Framework provides support for using STOMP over WebSocket through the spring-messaging and spring-websocket modules. Here is an example of exposing a STOMP WebSocket/SockJS endpoint at the URL path /portfoliowhere messages whose destination starts with "/app" are routed to message-handling methods (i.e. application work) and messages whose destinations start with "/topic" or "/queue" will be routed to the message broker (i.e. broadcasting to other connected clients):

								importorg.springframework.web.socket.config.annotation.EnableWebSocketMessageBroker;
								importorg.springframework.web.socket.config.annotation.StompEndpointRegistry;
								
									@Configuration
								
									@EnableWebSocketMessageBroker
								public
								classWebSocketConfig
								implementsWebSocketMessageBrokerConfigurer {
								
									@Override
								public
								voidregisterStompEndpoints(StompEndpointRegistry registry) { registry.addEndpoint(
								"/portfolio").withSockJS(); }
								
									@Override
								public
								voidconfigureMessageBroker(MessageBrokerRegistry config) { config.setApplicationDestinationPrefixes(
								"/app"); config.enableSimpleBroker(
								"/topic",
								"/queue"); } }

and in XML:

								<beans
								xmlns=
								"http://www.springframework.org/schema/beans"
								xmlns:xsi=
								"http://www.w3.org/2001/XMLSchema-instance"
								xmlns:websocket=
								"http://www.springframework.org/schema/websocket"
								xsi:schemaLocation=
								" http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/websocket http://www.springframework.org/schema/websocket/spring-websocket.xsd"
								>
								<websocket:message-broker
								application-destination-prefix=
								"/app"
								>
								<websocket:stomp-endpoint
								path=
								"/portfolio"
								>
								<websocket:sockjs/>
								</websocket:stomp-endpoint>
								<websocket:simple-broker
								prefix=
								"/topic, /queue"
								/>
								</websocket:message-broker>
								</beans>
[Note] Note

The "/app" prefix is arbitrary. You can pick any prefix. It’s simply meant to differentiate messages to be routed to message-handling methods to do application work vs messages to be routed to the broker to broadcast to subscribed clients.

The "/topic" and "/queue" prefixes depend on the broker in use. In the case of the simple, in-memory broker the prefixes do not have any special meaning; it’s merely a convention that indicates how the destination is used (pub-sub targetting many subscribers or point-to-point messages typically targeting an individual recipient). In the case of using a dedicated broker, most brokers use "/topic" as a prefix for destinations with pub-sub semantics and "/queue" for destinations with point-to-point semantics. Check the STOMP page of the broker to see the destination semantics it supports.

On the browser side, a client might connect as follows using stomp.jsand the sockjs-client:

								varsocket =
								newSockJS(
								"/spring-websocket-portfolio/portfolio");
								varstompClient = Stomp.over(socket); stompClient.connect({},
								function(frame) { }

Or if connecting via WebSocket (without SockJS):

								varsocket =
								newWebSocket(
								"/spring-websocket-portfolio/portfolio");
								varstompClient = Stomp.over(socket); stompClient.connect({},
								function(frame) { }

Note that the stompClientabove does not need to specify loginand passcodeheaders. Even if it did, they would be ignored, or rather overridden, on the server side. See the sections Section 26.4.8, “Connections To Full-Featured Broker”and Section 26.4.10, “Authentication”for more information on authentication.

26.4.3 Flow of Messages

When a STOMP endpoint is configured, the Spring application acts as the STOMP broker to connected clients. This section provides a big picture overview of how messages flow within the application.

The spring-messagingmodule provides the foundation for asynchronous message processing. It contains a number of abstractions that originated in the Spring Integrationproject and are intended for use as building blocks in messaging applications:

  • Message — a message with headers and a payload.
  • MessageHandler — a contract for handling a message.
  • MessageChannel — a contract for sending a message enabling loose coupling between senders and receivers.
  • SubscribableChannel — extends MessageChanneland sends messages to registered MessageHandlersubscribers.
  • ExecutorSubscribableChannel — a concrete implementation of SubscribableChannelthat can deliver messages asynchronously via a thread pool.

The @EnableWebSocketMessageBrokerJava config and the <websocket:message-broker>XML config both assemble a concrete message flow. Below is a diagram of the part of the setup when using the simple, in-memory broker:

message flow simple broker

The above setup that includes 3 message channels:

  • "clientInboundChannel"for messages from WebSocket clients.
  • "clientOutboundChannel"for messages to WebSocket clients.
  • "brokerChannel"for messages to the broker from within the application.

The same three channels are also used with a dedicated broker except here a "broker relay" takes the place of the simple broker:

message flow broker relay

Messages on the "clientInboundChannel"can flow to annotated methods for application handling (e.g. a stock trade execution request) or can be forwarded to the broker (e.g. client subscribing for stock quotes). The STOMP destination is used for simple prefix-based routing. For example the "/app" prefix could route messages to annotated methods while the "/topic" and "/queue" prefixes could route messages to the broker.

When a message-handling annotated method has a return type, its return value is sent as the payload of a Spring Messageto the "brokerChannel". The broker in turn broadcasts the message to clients. Sending a message to a destination can also be done from anywhere in the application with the help of a messaging template. For example, an HTTP POST handling method can broadcast a message to connected clients, or a service component may periodically broadcast stock quotes.

Below is a simple example to illustrate the flow of messages:

								
									@Configuration
								
									@EnableWebSocketMessageBroker
								public
								classWebSocketConfig
								implementsWebSocketMessageBrokerConfigurer {
								
									@Override
								public
								voidregisterStompEndpoints(StompEndpointRegistry registry) { registry.addEndpoint(
								"/portfolio"); }
								
									@Override
								public
								voidconfigureMessageBroker(MessageBrokerRegistry registry) { registry.setApplicationDestinationPrefixes(
								"/app"); registry.enableSimpleBroker(
								"/topic"); } }
								
									@Controller
								public
								classGreetingController {
								
									@MessageMapping("/greeting"){
								publicString handle(String greeting) {
								return
								"["+ getTimestamp() +
								": "+ greeting; } }

The following explains the message flow for the above example:

  • WebSocket clients connect to the WebSocket endpoint at "/portfolio".
  • Subscriptions to "/topic/greeting" pass through the "clientInboundChannel" and are forwarded to the broker.
  • Greetings sent to "/app/greeting" pass through the "clientInboundChannel" and are forwarded to the GreetingController. The controller adds the current time, and the return value is passed through the "brokerChannel" as a message to "/topic/greeting" (destination is selected based on a convention but can be overridden via @SendTo).
  • The broker in turn broadcasts messages to subscribers, and they pass through the "clientOutboundChannel".

The next section provides more details on annotated methods including the kinds of arguments and return values supported.

26.4.4 Annotation Message Handling

The @MessageMappingannotation is supported on methods of @Controllerclasses. It can be used for mapping methods to message destinations and can also be combined with the type-level @MessageMappingfor expressing shared mappings across all annotated methods within a controller.

By default destination mappings are treated as Ant-style, slash-separated, path patterns, e.g. "/foo*", "/foo/**". etc. They can also contain template variables, e.g. "/foo/{id}" that can then be referenced via @DestinationVariable-annotated method arguments.

[Note] Note

Applications can also use dot-separated destinations (vs slash). See Section 26.4.9, “Using Dot as Separator in @MessageMapping Destinations”.

The following method arguments are supported for @MessageMappingmethods:

  • Messagemethod argument to get access to the complete message being processed.
  • @Payload-annotated argument for access to the payload of a message, converted with a org.springframework.messaging.converter.MessageConverter. The presence of the annotation is not required since it is assumed by default. Payload method arguments annotated with validation annotations (like @Validated) will be subject to JSR-303 validation.
  • @Header-annotated arguments for access to a specific header value along with type conversion using an org.springframework.core.convert.converter.Converterif necessary.
  • @Headers-annotated method argument that must also be assignable to java.util.Mapfor access to all headers in the message.
  • MessageHeadersmethod argument for getting access to a map of all headers.
  • MessageHeaderAccessor, SimpMessageHeaderAccessor, or StompHeaderAccessorfor access to headers via typed accessor methods.
  • @DestinationVariable-annotated arguments for access to template variables extracted from the message destination. Values will be converted to the declared method argument type as necessary.
  • java.security.Principalmethod arguments reflecting the user logged in at the time of the WebSocket HTTP handshake.

The return value from an @MessageMappingmethod is converted with a org.springframework.messaging.converter.MessageConverterand used as the body of a new message that is then sent, by default, to the "brokerChannel"with the same destination as the client message but using the prefix "/topic"by default. An @SendTomessage level annotation can be used to specify any other destination instead. It can also be set a class-level to share a common destination.

An @SubscribeMappingannotation can also be used to map subscription requests to @Controllermethods. It is supported on the method level, but can also be combined with a type level @MessageMappingannotation that expresses shared mappings across all message handling methods within the same controller.

By default the return value from an @SubscribeMappingmethod is sent as a message directly back to the connected client and does not pass through the broker. This is useful for implementing request-reply message interactions; for example, to fetch application data when the application UI is being initialized. Or alternatively an @SubscribeMappingmethod can be annotated with @SendToin which case the resulting message is sent to the "brokerChannel"using the specified target destination.

[Note] Note

In some cases a controller may need to be decorated with an AOP proxy at runtime. One example is if you choose to have @Transactionalannotations directly on the controller. When this is the case, for controllers specifically, we recommend using class-based proxying. This is typically the default choice with controllers. However if a controller must implement an interface that is not a Spring Context callback (e.g. InitializingBean, *Aware, etc), you may need to explicitly configure class-based proxying. For example with <tx:annotation-driven />, change to <tx:annotation-driven proxy-target-class="true" />.

26.4.5 Sending Messages

What if you want to send messages to connected clients from any part of the application? Any application component can send messages to the "brokerChannel". The easiest way to do that is to have a SimpMessagingTemplateinjected, and use it to send messages. Typically it should be easy to have it injected by type, for example:

								
									@Controller
								public
								classGreetingController {
								privateSimpMessagingTemplate template;
								
									@Autowired
								publicGreetingController(SimpMessagingTemplate template) {
								this.template = template; }
								
									@RequestMapping(path="/greetings", method=POST)
								public
								voidgreet(String greeting) { String text =
								"["+ getTimestamp() +
								"]:"+ greeting;
								this.template.convertAndSend(
								"/topic/greetings", text); } }

But it can also be qualified by its name "brokerMessagingTemplate" if another bean of the same type exists.

26.4.6 Simple Broker

The built-in, simple message broker handles subscription requests from clients, stores them in memory, and broadcasts messages to connected clients with matching destinations. The broker supports path-like destinations, including subscriptions to Ant-style destination patterns.

[Note] Note

Applications can also use dot-separated destinations (vs slash). See Section 26.4.9, “Using Dot as Separator in @MessageMapping Destinations”.

26.4.7 Full-Featured Broker

The simple broker is great for getting started but supports only a subset of STOMP commands (e.g. no acks, receipts, etc.), relies on a simple message sending loop, and is not suitable for clustering. As an alternative, applications can upgrade to using a full-featured message broker.

Check the STOMP documentation for your message broker of choice (e.g. RabbitMQ, ActiveMQ, etc.), install the broker, and run it with STOMP support enabled. Then enable the STOMP broker relay in the Spring configuration instead of the simple broker.

Below is example configuration that enables a full-featured broker:

								
									@Configuration
								
									@EnableWebSocketMessageBroker
								public
								classWebSocketConfig
								implementsWebSocketMessageBrokerConfigurer {
								
									@Override
								public
								voidregisterStompEndpoints(StompEndpointRegistry registry) { registry.addEndpoint(
								"/portfolio").withSockJS(); }
								
									@Override
								public
								voidconfigureMessageBroker(MessageBrokerRegistry registry) { registry.enableStompBrokerRelay(
								"/topic",
								"/queue"); registry.setApplicationDestinationPrefixes(
								"/app"); } }

XML configuration equivalent:

								<beans
								xmlns=
								"http://www.springframework.org/schema/beans"
								xmlns:xsi=
								"http://www.w3.org/2001/XMLSchema-instance"
								xmlns:websocket=
								"http://www.springframework.org/schema/websocket"
								xsi:schemaLocation=
								" http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/websocket http://www.springframework.org/schema/websocket/spring-websocket.xsd"
								>
								<websocket:message-broker
								application-destination-prefix=
								"/app"
								>
								<websocket:stomp-endpoint
								path=
								"/portfolio"
								/>
								<websocket:sockjs/>
								</websocket:stomp-endpoint>
								<websocket:stomp-broker-relay
								prefix=
								"/topic,/queue"
								/>
								</websocket:message-broker>
								</beans>

The "STOMP broker relay" in the above configuration is a Spring MessageHandlerthat handles messages by forwarding them to an external message broker. To do so it establishes TCP connections to the broker, forwards all messages to it, and then forwards all messages received from the broker to clients through their WebSocket sessions. Essentially it acts as a "relay" that forwards messages in both directions.

[Note] Note

Please add a dependency on org.projectreactor:reactor-netfor TCP connection management.

Furthermore, application components (e.g. HTTP request handling methods, business services, etc.) can also send messages to the broker relay, as described in Section 26.4.5, “Sending Messages”, in order to broadcast messages to subscribed WebSocket clients.

In effect, the broker relay enables robust and scalable message broadcasting.

26.4.8 Connections To Full-Featured Broker

A STOMP broker relay maintains a single "system" TCP connection to the broker. This connection is used for messages originating from the server-side application only, not for receiving messages. You can configure the STOMP credentials for this connection, i.e. the STOMP frame loginand passcodeheaders. This is exposed in both the XML namespace and the Java config as the systemLogin/ systemPasscodeproperties with default values guest/ guest.

The STOMP broker relay also creates a separate TCP connection for every connected WebSocket client. You can configure the STOMP credentials to use for all TCP connections created on behalf of clients. This is exposed in both the XML namespace and the Java config as the clientLogin/ clientPasscodeproperties with default values guest/ guest.

[Note] Note

The STOMP broker relay always sets the loginand passcodeheaders on every CONNECTframe that it forwards to the broker on behalf of clients. Therefore WebSocket clients need not set those headers; they will be ignored. As the following section explains, instead WebSocket clients should rely on HTTP authentication to protect the WebSocket endpoint and establish the client identity.

The STOMP broker relay also sends and receives heartbeats to and from the message broker over the "system" TCP connection. You can configure the intervals for sending and receiving heartbeats (10 seconds each by default). If connectivity to the broker is lost, the broker relay will continue to try to reconnect, every 5 seconds, until it succeeds.

[Note] Note

A Spring bean can implement ApplicationListener<BrokerAvailabilityEvent>in order to receive notifications when the "system" connection to the broker is lost and re-established. For example a Stock Quote service broadcasting stock quotes can stop trying to send messages when there is no active "system" connection.

The STOMP broker relay can also be configured with a virtualHostproperty. The value of this property will be set as the hostheader of every CONNECTframe and may be useful for example in a cloud environment where the actual host to which the TCP connection is established is different from the host providing the cloud-based STOMP service.

26.4.9 Using Dot as Separator in @MessageMapping Destinations

Although slash-separated path patterns are familiar to web developers, in messaging it is common to use a "." as the separator, for example in the names of topics, queues, exchanges, etc. Applications can also switch to using "." (dot) instead of "/" (slash) as the separator in @MessageMappingmappings by configuring a custom AntPathMatcher.

In Java config:

								
									@Configuration
								
									@EnableWebSocketMessageBroker
								public
								classWebSocketConfig
								extendsAbstractWebSocketMessageBrokerConfigurer {
								// ...
								
									@Override
								public
								voidconfigureMessageBroker(MessageBrokerRegistry registry) { registry.enableStompBrokerRelay(
								"/queue/",
								"/topic/"); registry.setApplicationDestinationPrefixes(
								"/app"); registry.setPathMatcher(
								newAntPathMatcher(
								".")); } }

In XML config:

								<beans
								xmlns=
								"http://www.springframework.org/schema/beans"
								xmlns:xsi=
								"http://www.w3.org/2001/XMLSchema-instance"
								xmlns:websocket=
								"http://www.springframework.org/schema/websocket"
								xsi:schemaLocation=
								" http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/websocket http://www.springframework.org/schema/websocket/spring-websocket.xsd"
								>
								<websocket:message-broker
								application-destination-prefix=
								"/app"
								path-matcher=
								"pathMatcher"
								>
								<websocket:stomp-endpoint
								path=
								"/stomp"
								/>
								<websocket:simple-broker
								prefix=
								"/topic, /queue"
								/>
								</websocket:message-broker>
								<bean
								id=
								"pathMatcher"
								class=
								"org.springframework.util.AntPathMatcher"
								>
								<constructor-arg
								index=
								"0"
								value=
								"."
								/>
								</bean>
								</beans>

And below is a simple example to illustrate a controller with "." separator:

								
									@Controller
								
									@MessageMapping("foo")
								public
								classFooController {
								
									@MessageMapping("bar.{baz}")
								public
								voidhandleBaz(
								
									@DestinationVariableString baz) { } }

If the application prefix is set to "/app" then the foo method is effectively mapped to "/app/foo.bar.{baz}".

26.4.10 Authentication

In a WebSocket-style application it is often useful to know who sent a message. Therefore some form of authentication is needed to establish the user identity and associate it with the current session.

Existing Web applications already use HTTP based authentication. For example Spring Security can secure the HTTP URLs of the application as usual. Since a WebSocket session begins with an HTTP handshake, that means URLs mapped to STOMP/WebSocket are already automatically protected and require authentication. Moreover the page that opens the WebSocket connection is itself likely protected and so by the time of the actual handshake, the user should have been authenticated.

When a WebSocket handshake is made and a new WebSocket session is created, Spring’s WebSocket support automatically propagates the java.security.Principalfrom the HTTP request to the WebSocket session. After that every message flowing through the application on that WebSocket session is enriched with the user information. It’s present in the message as a header. Controller methods can access the current user by adding a method argument of type javax.security.Principal.

Note that even though the STOMP CONNECTframe has "login" and "passcode" headers that can be used for authentication, Spring’s STOMP WebSocket support ignores them and currently expects users to have been authenticated already via HTTP.

In some cases it may be useful to assign an identity to a WebSocket session even when the user has not been formally authenticated. For example, a mobile app might assign some identity to anonymous users, perhaps based on geographical location. The do that currently, an application can sub-class DefaultHandshakeHandlerand override the determineUsermethod. The custom handshake handler can then be plugged in (see examples in Section 26.2.4, “Deployment Considerations”).

26.4.11 User Destinations

An application can send messages targeting a specific user, and Spring’s STOMP support recognizes destinations prefixed with "/user/"for this purpose. For example, a client might subscribe to the destination "/user/queue/position-updates". This destination will be handled by the UserDestinationMessageHandlerand transformed into a destination unique to the user session, e.g. "/queue/position-updates-user123". This provides the convenience of subscribing to a generically named destination while at the same time ensuring no collisions with other users subscribing to the same destination so that each user can receive unique stock position updates.

On the sending side messages can be sent to a destination such as "/user/{username}/queue/position-updates", which in turn will be translated by the UserDestinationMessageHandlerinto one or more destinations, one for each session associated with the user. This allows any component within the application to send messages targeting a specific user without necessarily knowing anything more than their name and the generic destination. This is also supported through an annotation as well as a messaging template.

For example, a message-handling method can send messages to the user associated with the message being handled through the @SendToUserannotation (also supported on the class-level to share a common destination):

								
									@Controller
								public
								classPortfolioController {
								
									@MessageMapping("/trade")
								
									@SendToUser("/queue/position-updates")
								publicTradeResult executeTrade(Trade trade, Principal principal) {
								// ...
								returntradeResult; } }

If the user has more than one session, by default all of the sessions subscribed to the given destination are targeted. However sometimes, it may be necessary to target only the session that sent the message being handled. This can be done by setting the broadcastattribute to false, for example:

								
									@Controller
								public
								classMyController {
								
									@MessageMapping("/action")
								public
								voidhandleAction()
								throwsException{
								// raise MyBusinessException here}
								
									@MessageExceptionHandler
								
									@SendToUser(destinations="/queue/errors", broadcast=false)
								publicApplicationError handleException(MyBusinessException exception) {
								// ...
								returnappError; } }
[Note] Note

While user destinations generally imply an authenticated user, it isn’t required strictly. A WebSocket session that is not associated with an authenticated user can subscribe to a user destination. In such cases the @SendToUserannotation will behave exactly the same as with broadcast=false, i.e. targeting only the session that sent the message being handled.

It is also possible to send a message to user destinations from any application component by injecting the SimpMessagingTemplatecreated by the Java config or XML namespace, for example (the bean name is "brokerMessagingTemplate"if required for qualification with @Qualifier):

								
									@Service
								public
								classTradeServiceImpl
								implementsTradeService {
								private
								finalSimpMessagingTemplate messagingTemplate;
								
									@Autowired
								publicTradeServiceImpl(SimpMessagingTemplate messagingTemplate) {
								this.messagingTemplate = messagingTemplate; }
								// ...
								public
								voidafterTradeExecuted(Trade trade) {
								this.messagingTemplate.convertAndSendToUser( trade.getUserName(),
								"/queue/position-updates", trade.getResult()); } }
[Note] Note

When using user destinations with an external message broker, check the broker documentation on how to manage inactive queues, so that when the user session is over, all unique user queues are removed. For example, RabbitMQ creates auto-delete queues when destinations like /exchange/amq.direct/position-updatesare used. So in that case the client could subscribe to /user/exchange/amq.direct/position-updates. Similarly, ActiveMQ has configuration optionsfor purging inactive destinations.

In a multi-application server scenario a user destination may remain unresolved because the user is connected to a different server. In such cases you can configure a destination to broadcast unresolved messages to so that other servers have a chance to try. This can be done through the userDestinationBroadcastproperty of the MessageBrokerRegistryin Java config and the user-destination-broadcastattribute of the message-brokerelement in XML.

26.4.12 Listening To ApplicationContext Events and Intercepting Messages

Several ApplicationContextevents (listed below) are published and can be received by implementing Spring’s ApplicationListenerinterface.

  • BrokerAvailabilityEvent — indicates when the broker becomes available/unavailable. While the "simple" broker becomes available immediately on startup and remains so while the application is running, the STOMP "broker relay" may lose its connection to the full featured broker, for example if the broker is restarted. The broker relay has reconnect logic and will re-establish the "system" connection to the broker when it comes back, hence this event is published whenever the state changes from connected to disconnected and vice versa. Components using the SimpMessagingTemplateshould subscribe to this event and avoid sending messages at times when the broker is not available. In any case they should be prepared to handle MessageDeliveryExceptionwhen sending a message.
  • SessionConnectEvent — published when a new STOMP CONNECT is received indicating the start of a new client session. The event contains the message representing the connect including the session id, user information (if any), and any custom headers the client may have sent. This is useful for tracking client sessions. Components subscribed to this event can wrap the contained message using SimpMessageHeaderAccessoror StompMessageHeaderAccessor.
  • SessionConnectedEvent — published shortly after a SessionConnectEventwhen the broker has sent a STOMP CONNECTED frame in response to the CONNECT. At this point the STOMP session can be considered fully established.
  • SessionSubscribeEvent — published when a new STOMP SUBSCRIBE is received.
  • SessionUnsubscribeEvent — published when a new STOMP UNSUBSCRIBE is received.
  • SessionDisconnectEvent — published when a STOMP session ends. The DISCONNECT may have been sent from the client, or it may also be automatically generated when the WebSocket session is closed. In some cases this event may be published more than once per session. Components should be idempotent with regard to multiple disconnect events.
[Note] Note

When using a full-featured broker, the STOMP "broker relay" automatically reconnects the "system" connection in case the broker becomes temporarily unavailable. Client connections however are not automatically reconnected. Assuming heartbeats are enabled, the client will typically notice the broker is not responding within 10 seconds. Clients need to implement their own reconnect logic.

Furthermore, an application can directly intercept every incoming and outgoing message by registering a ChannelInterceptoron the respective message channel. For example to intercept inbound messages:

								
									@Configuration
								
									@EnableWebSocketMessageBroker
								public
								classWebSocketConfig
								extendsAbstractWebSocketMessageBrokerConfigurer {
								
									@Override
								public
								voidconfigureClientInboundChannel(ChannelRegistration registration) { registration.setInterceptors(
								newMyChannelInterceptor()); } }

A custom ChannelInterceptorcan extend the empty method base class ChannelInterceptorAdapterand use StompHeaderAccessoror SimpMessageHeaderAccessorto access information about the message.

								public
								classMyChannelInterceptor
								extendsChannelInterceptorAdapter {
								
									@Override
								publicMessage<?> preSend(Message<?> message, MessageChannel channel) { StompHeaderAccessor accessor = StompHeaderAccessor.wrap(message); StompCommand command = accessor.getStompCommand();
								// ...
								returnmessage; } }

26.4.13 STOMP Client

Spring provides a STOMP over WebSocket client and a STOMP over TCP client.

To begin create and configure WebSocketStompClient:

WebSocketClient webSocketClient =
								newStandardWebSocketClient(); WebSocketStompClient stompClient =
								newWebSocketStompClient(webSocketClient); stompClient.setMessageConverter(
								newStringMessageConverter()); stompClient.setTaskScheduler(taskScheduler);
								// for heartbeats

In the above example StandardWebSocketClientcould be replaced with SockJsClientsince that is also an implementation of WebSocketClient. The SockJsClientcan use WebSocket or HTTP-based transport as a fallback. For more details see Section 26.3.7, “SockJS Client”.

Next establish a connection and provide a handler for the STOMP session:

String url =
								"ws://127.0.0.1:8080/endpoint"; StompSessionHandler sessionHandler =
								newMyStompSessionHandler(); stompClient.connect(url, sessionHandler);

When the session is ready for use the handler is notified:

								public
								classMyStompSessionHandler
								extendsStompSessionHandlerAdapter {
								
									@Override
								public
								voidafterConnected(StompSession session, StompHeaders connectedHeaders) {
								// ...} }

Once the session is established any payload can be sent and that will be serialized with the configured MessageConverter:

session.send(
								"/topic/foo",
								"payload");

You can also subscribe to destinations. The subscribemethods require a handler for messages on the subscription and return a Subscriptionhandle that can be used to unsubscribe. For each received message the handler can specify the target Object type the payload should be deserialized to:

session.subscribe(
								"/topic/foo",
								newStompFrameHandler() {
								
									@Override
								publicType getPayloadType(StompHeaders headers) {
								returnString.
								class; }
								
									@Override
								public
								voidhandleFrame(StompHeaders headers, Object payload) {
								// ...} });

To enable STOMP heartbeat configure WebSocketStompClientwith a TaskSchedulerand optionally customize the heartbeat intervals, 10 seconds for write inactivity which causes a heartbeat to be sent and 10 seconds for read inactivity which closes the connection.

[Note] Note

When using WebSocketStompClientfor performance tests to simulate thousands of clients from the same machine consider turning off heartbeats since each connection schedules its own heartbeat tasks and that’s not optimized for a a large number of clients running on the same machine.

The STOMP protocol also supports receipts where the client must add a "receipt" header to which the server responds with a RECEIPT frame after the send or subscribe are processed. To support this the StompSessionoffers setAutoReceipt(boolean)that causes a "receipt" header to be added on every subsequent send or subscribe. Alternatively you can also manually add a "receipt" header to the StompHeaders. Both send and subscribe return an instance of Receiptablethat can be used to register for receipt success and failure callbacks. For this feature the client must be configured with a TaskSchedulerand the amount of time before a receipt expires (15 seconds by default).

Note that StompSessionHandleritself is a StompFrameHandlerwhich allows it to handle ERROR frames in addition to the handleExceptioncallback for exceptions from the handling of messages, and handleTransportErrorfor transport-level errors including ConnectionLostException.

26.4.14 WebSocket Scope

Each WebSocket session has a map of attributes. The map is attached as a header to inbound client messages and may be accessed from a controller method, for example:

								
									@Controller
								public
								classMyController {
								
									@MessageMapping("/action")
								public
								voidhandle(SimpMessageHeaderAccessor headerAccessor) { Map<String, Object> attrs = headerAccessor.getSessionAttributes();
								// ...} }

It is also possible to declare a Spring-managed bean in the websocketscope. WebSocket-scoped beans can be injected into controllers and any channel interceptors registered on the "clientInboundChannel". Those are typically singletons and live longer than any individual WebSocket session. Therefore you will need to use a scope proxy mode for WebSocket-scoped beans:

								
									@Component
								
									@Scope(scopeName = "websocket", proxyMode = ScopedProxyMode.TARGET_CLASS)
								public
								classMyBean {
								
									@PostConstruct
								public
								voidinit() {
								// Invoked after dependencies injected}
								// ...
								
									@PreDestroy
								public
								voiddestroy() {
								// Invoked when the WebSocket session ends} }
								
									@Controller
								public
								classMyController {
								private
								finalMyBean myBean;
								
									@Autowired
								publicMyController(MyBean myBean) {
								this.myBean = myBean; }
								
									@MessageMapping("/action")
								public
								voidhandle() {
								// this.myBean from the current WebSocket session} }

As with any custom scope, Spring initializes a new MyBeaninstance the first time it is accessed from the controller and stores the instance in the WebSocket session attributes. The same instance is returned subsequently until the session ends. WebSocket-scoped beans will have all Spring lifecycle methods invoked as shown in the examples above.

26.4.15 Configuration and Performance

There is no silver bullet when it comes to performance. Many factors may affect it including the size of messages, the volume, whether application methods perform work that requires blocking, as well as external factors such as network speed and others. The goal of this section is to provide an overview of the available configuration options along with some thoughts on how to reason about scaling.

In a messaging application messages are passed through channels for asynchronous executions backed by thread pools. Configuring such an application requires good knowledge of the channels and the flow of messages. Therefore it is recommended to review Section 26.4.3, “Flow of Messages”.

The obvious place to start is to configure the thread pools backing the "clientInboundChannel"and the "clientOutboundChannel". By default both are configured at twice the number of available processors.

If the handling of messages in annotated methods is mainly CPU bound then the number of threads for the "clientInboundChannel"should remain close to the number of processors. If the work they do is more IO bound and requires blocking or waiting on a database or other external system then the thread pool size will need to be increased.

[Note] Note

ThreadPoolExecutorhas 3 important properties. Those are the core and the max thread pool size as well as the capacity for the queue to store tasks for which there are no available threads.

A common point of confusion is that configuring the core pool size (e.g. 10) and max pool size (e.g. 20) results in a thread pool with 10 to 20 threads. In fact if the capacity is left at its default value of Integer.MAX_VALUE then the thread pool will never increase beyond the core pool size since all additional tasks will be queued.

Please review the Javadoc of ThreadPoolExecutorto learn how these properties work and understand the various queuing strategies.

On the "clientOutboundChannel"side it is all about sending messages to WebSocket clients. If clients are on a fast network then the number of threads should remain close to the number of available processors. If they are slow or on low bandwidth they will take longer to consume messages and put a burden on the thread pool. Therefore increasing the thread pool size will be necessary.

While the workload for the "clientInboundChannel" is possible to predict — after all it is based on what the application does — how to configure the "clientOutboundChannel" is harder as it is based on factors beyond the control of the application. For this reason there are two additional properties related to the sending of messages. Those are the "sendTimeLimit"and the "sendBufferSizeLimit". Those are used to configure how long a send is allowed to take and how much data can be buffered when sending messages to a client.

The general idea is that at any given time only a single thread may be used to send to a client. All additional messages meanwhile get buffered and you can use these properties to decide how long sending a message is allowed to take and how much data can be buffered in the mean time. Please review the Javadoc and documentation of the XML schema for this configuration for important additional details.

Here is example configuration:

								
									@Configuration
								
									@EnableWebSocketMessageBroker
								public
								classWebSocketConfig
								implementsWebSocketMessageBrokerConfigurer {
								
									@Override
								public
								voidconfigureWebSocketTransport(WebSocketTransportRegistration registration) { registration.setSendTimeLimit(
								15*
								1000).setSendBufferSizeLimit(
								512*
								1024); }
								// ...}
								<beans
								xmlns=
								"http://www.springframework.org/schema/beans"
								xmlns:xsi=
								"http://www.w3.org/2001/XMLSchema-instance"
								xmlns:websocket=
								"http://www.springframework.org/schema/websocket"
								xsi:schemaLocation=
								" http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/websocket http://www.springframework.org/schema/websocket/spring-websocket.xsd"
								>
								<websocket:message-broker>
								<websocket:transport
								send-timeout=
								"15000"
								send-buffer-size=
								"524288"
								/>
								<!-- ... -->
								</websocket:message-broker>
								</beans>

The WebSocket transport configuration shown above can also be used to configure the maximum allowed size for incoming STOMP messages. Although in theory a WebSocket message can be almost unlimited in size, in practice WebSocket servers impose limits — for example, 8K on Tomcat and 64K on Jetty. For this reason STOMP clients such as stomp.js split larger STOMP messages at 16K boundaries and send them as multiple WebSocket messages thus requiring the server to buffer and re-assemble.

Spring’s STOMP over WebSocket support does this so applications can configure the maximum size for STOMP messages irrespective of WebSocket server specific message sizes. Do keep in mind that the WebSocket message size will be automatically adjusted if necessary to ensure they can carry 16K WebSocket messages at a minimum.

Here is example configuration:

								
									@Configuration
								
									@EnableWebSocketMessageBroker
								public
								classWebSocketConfig
								implementsWebSocketMessageBrokerConfigurer {
								
									@Override
								public
								voidconfigureWebSocketTransport(WebSocketTransportRegistration registration) { registration.setMessageSizeLimit(
								128*
								1024); }
								// ...}
								<beans
								xmlns=
								"http://www.springframework.org/schema/beans"
								xmlns:xsi=
								"http://www.w3.org/2001/XMLSchema-instance"
								xmlns:websocket=
								"http://www.springframework.org/schema/websocket"
								xsi:schemaLocation=
								" http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/websocket http://www.springframework.org/schema/websocket/spring-websocket.xsd"
								>
								<websocket:message-broker>
								<websocket:transport
								message-size=
								"131072"
								/>
								<!-- ... -->
								</websocket:message-broker>
								</beans>

An important point about scaling is using multiple application instances. Currently it is not possible to do that with the simple broker. However when using a full-featured broker such as RabbitMQ, each application instance connects to the broker and messages broadcast from one application instance can be broadcast through the broker to WebSocket clients connected through any other application instances.

26.4.16 Runtime Monitoring

When using @EnableWebSocketMessageBrokeror <websocket:message-broker>key infrastructure components automatically gather stats and counters that provide important insight into the internal state of the application. The configuration also declares a bean of type WebSocketMessageBrokerStatsthat gathers all available information in one place and by default logs it at INFOlevel once every 30 minutes. This bean can be exported to JMX through Spring’s MBeanExporterfor viewing at runtime, for example through JDK’s jconsole. Below is a summary of the available information.

Client WebSocket Sessions
Current
indicates how many client sessions there are currently with the count further broken down by WebSocket vs HTTP streaming and polling SockJS sessions.
Total
indicates how many total sessions have been established.
Abnormally Closed
Connect Failures
these are sessions that got established but were closed after not having received any messages within 60 seconds. This is usually an indication of proxy or network issues.
Send Limit Exceeded
sessions closed after exceeding the configured send timeout or the send buffer limits which can occur with slow clients (see previous section).
Transport Errors
sessions closed after a transport error such as failure to read or write to a WebSocket connection or HTTP request/response.
STOMP Frames
the total number of CONNECT, CONNECTED, and DISCONNECT frames processed indicating how many clients connected on the STOMP level. Note that the DISCONNECT count may be lower when sessions get closed abnormally or when clients close without sending a DISCONNECT frame.
STOMP Broker Relay
TCP Connections
indicates how many TCP connections on behalf of client WebSocket sessions are established to the broker. This should be equal to the number of client WebSocket sessions + 1 additional shared "system" connection for sending messages from within the application.
STOMP Frames
the total number of CONNECT, CONNECTED, and DISCONNECT frames forwarded to or received from the broker on behalf of clients. Note that a DISCONNECT frame is sent to the broker regardless of how the client WebSocket session was closed. Therefore a lower DISCONNECT frame count is an indication that the broker is pro-actively closing connections, may be because of a heartbeat that didn’t arrive in time, an invalid input frame, or other.
Client Inbound Channel
stats from thread pool backing the "clientInboundChannel" providing insight into the health of incoming message processing. Tasks queueing up here is an indication the application may be too slow to handle messages. If there I/O bound tasks (e.g. slow database query, HTTP request to 3rd party REST API, etc) consider increasing the thread pool size.
Client Outbound Channel
stats from the thread pool backing the "clientOutboundChannel" providing insight into the health of broadcasting messages to clients. Tasks queueing up here is an indication clients are too slow to consume messages. One way to address this is to increase the thread pool size to accommodate the number of concurrent slow clients expected. Another option is to reduce the send timeout and send buffer size limits (see the previous section).
SockJS Task Scheduler
stats from thread pool of the SockJS task scheduler which is used to send heartbeats. Note that when heartbeats are negotiated on the STOMP level the SockJS heartbeats are disabled.

26.4.17 Testing Annotated Controller Methods

There are two main approaches to testing applications using Spring’s STOMP over WebSocket support. The first is to write server-side tests verifying the functionality of controllers and their annotated message handling methods. The second is to write full end-to-end tests that involve running a client and a server.

The two approaches are not mutually exclusive. On the contrary each has a place in an overall test strategy. Server-side tests are more focused and easier to write and maintain. End-to-end integration tests on the other hand are more complete and test much more, but they’re also more involved to write and maintain.

The simplest form of server-side tests is to write controller unit tests. However this is not useful enough since much of what a controller does depends on its annotations. Pure unit tests simply can’t test that.

Ideally controllers under test should be invoked as they are at runtime, much like the approach to testing controllers handling HTTP requests using the Spring MVC Test framework. i.e. without running a Servlet container but relying on the Spring Framework to invoke the annotated controllers. Just like with Spring MVC Test here there are two two possible alternatives, either using a "context-based" or "standalone" setup:

  1. Load the actual Spring configuration with the help of the Spring TestContext framework, inject "clientInboundChannel" as a test field, and use it to send messages to be handled by controller methods.
  2. Manually set up the minimum Spring framework infrastructure required to invoke controllers (namely the SimpAnnotationMethodMessageHandler) and pass messages for controllers directly to it.

Both of these setup scenarios are demonstrated in the tests for the stock portfoliosample application.

The second approach is to create end-to-end integration tests. For that you will need to run a WebSocket server in embedded mode and connect to it as a WebSocket client sending WebSocket messages containing STOMP frames. The tests for the stock portfoliosample application also demonstrates this approach using Tomcat as the embedded WebSocket server and a simple STOMP client for test purposes.

27. CORS Support

27.1 Introduction

For security reasons, browsers prohibit AJAX calls to resources residing outside the current origin. For example, as you’re checking your bank account in one tab, you could have the evil.com website open in another tab. The scripts from evil.com should not be able to make AJAX requests to your bank API (e.g., withdrawing money from your account!) using your credentials.

Cross-origin resource sharing(CORS) is a W3C specificationimplemented by most browsersthat allows you to specify in a flexible way what kind of cross domain requests are authorized, instead of using some less secured and less powerful hacks like IFRAME or JSONP.

As of Spring Framework 4.2, CORS is supported out of the box. CORS requests ( including preflight ones with an OPTIONSmethod) are automatically dispatched to the various registered HandlerMappings. They handle CORS preflight requests and intercept CORS simple and actual requests thanks to a CorsProcessorimplementation ( DefaultCorsProcessorby default) in order to add the relevant CORS response headers (like Access-Control-Allow-Origin) based on the CORS configuration you have provided.

[Note] Note

Since CORS requests are automatically dispatched, you do not needto change the DispatcherServlet dispatchOptionsRequestinit parameter value; using its default value ( false) is the recommended approach.

27.2 Controller method CORS configuration

You can add an @CrossOriginannotation to your @RequestMappingannotated handler method in order to enable CORS on it. By default @CrossOriginallows all origins and the HTTP methods specified in the @RequestMappingannotation:

							
								@RestController
							
								@RequestMapping("/account")
							public
							classAccountController {
							
								@CrossOrigin
							
								@RequestMapping("/{id}")
							publicAccount retrieve(
							
								@PathVariableLong id) {
							// ...}
							
								@RequestMapping(method = RequestMethod.DELETE, path = "/{id}")
							public
							voidremove(
							
								@PathVariableLong id) {
							// ...} }

It is also possible to enable CORS for the whole controller:

							
								@CrossOrigin(origins = "http://domain2.com", maxAge = 3600)
							
								@RestController
							
								@RequestMapping("/account")
							public
							classAccountController {
							
								@RequestMapping("/{id}")
							publicAccount retrieve(
							
								@PathVariableLong id) {
							// ...}
							
								@RequestMapping(method = RequestMethod.DELETE, path = "/{id}")
							public
							voidremove(
							
								@PathVariableLong id) {
							// ...} }

In the above example CORS support is enabled for both the retrieve()and the remove()handler methods, and you can also see how you can customize the CORS configuration using @CrossOriginattributes.

You can even use both controller-level and method-level CORS configurations; Spring will then combine attributes from both annotations to create merged CORS configuration.

							
								@CrossOrigin(maxAge = 3600)
							
								@RestController
							
								@RequestMapping("/account")
							public
							classAccountController {
							
								@CrossOrigin("http://domain2.com")
							
								@RequestMapping("/{id}")
							publicAccount retrieve(
							
								@PathVariableLong id) {
							// ...}
							
								@RequestMapping(method = RequestMethod.DELETE, path = "/{id}")
							public
							voidremove(
							
								@PathVariableLong id) {
							// ...} }

27.3 Global CORS configuration

In addition to fine-grained, annotation-based configuration you’ll probably want to define some global CORS configuration as well. This is similar to using filters but can be declared within Spring MVC and combined with fine-grained @CrossOriginconfiguration. By default all origins and GET, HEAD, and POSTmethods are allowed.

27.3.1 JavaConfig

Enabling CORS for the whole application is as simple as:

								
									@Configuration
								
									@EnableWebMvc
								public
								classWebConfig
								extendsWebMvcConfigurerAdapter {
								
									@Override
								public
								voidaddCorsMappings(CorsRegistry registry) { registry.addMapping(
								"/**"); } }

You can easily change any properties, as well as only apply this CORS configuration to a specific path pattern:

								
									@Configuration
								
									@EnableWebMvc
								public
								classWebConfig
								extendsWebMvcConfigurerAdapter {
								
									@Override
								public
								voidaddCorsMappings(CorsRegistry registry) { registry.addMapping(
								"/api/**") .allowedOrigins(
								"http://domain2.com") .allowedMethods(
								"PUT",
								"DELETE") .allowedHeaders(
								"header1",
								"header2",
								"header3") .exposedHeaders(
								"header1",
								"header2") .allowCredentials(false).maxAge(
								3600); } }

27.3.2 XML namespace

The following minimal XML configuration enables CORS for the /**path pattern with the same default properties as with the aforementioned JavaConfig examples:

								<mvc:cors>
								<mvc:mapping
								path=
								"/**"
								/>
								</mvc:cors>

It is also possible to declare several CORS mappings with customized properties:

								<mvc:cors>
								<mvc:mapping
								path=
								"/api/**"
								allowed-origins=
								"http://domain1.com, http://domain2.com"
								allowed-methods=
								"GET, PUT"
								allowed-headers=
								"header1, header2, header3"
								exposed-headers=
								"header1, header2"
								allow-credentials=
								"false"
								max-age=
								"123"
								/>
								<mvc:mapping
								path=
								"/resources/**"
								allowed-origins=
								"http://domain1.com"
								/>
								</mvc:cors>

27.4 Advanced Customization

CorsConfigurationallows you to specify how the CORS requests should be processed: allowed origins, headers, methods, etc. It can be provided in various ways:

27.5 Filter based CORS support

In order to support CORS with filter-based security frameworks like Spring Security, or with other libraries that do not support natively CORS, Spring Framework also provides a CorsFilter. Instead of using @CrossOriginor WebMvcConfigurer#addCorsMappings(CorsRegistry), you need to register a custom filter defined like bellow:

							importorg.springframework.web.cors.CorsConfiguration;
							importorg.springframework.web.cors.UrlBasedCorsConfigurationSource;
							importorg.springframework.web.filter.CorsFilter;
							public
							classMyCorsFilter
							extendsCorsFilter {
							publicMyCorsFilter() {
							super(configurationSource()); }
							private
							staticUrlBasedCorsConfigurationSource configurationSource() { CorsConfiguration config =
							newCorsConfiguration(); config.setAllowCredentials(true); config.addAllowedOrigin(
							"http://domain1.com"); config.addAllowedHeader(
							"*"); config.addAllowedMethod(
							"*"); UrlBasedCorsConfigurationSource source =
							newUrlBasedCorsConfigurationSource(); source.registerCorsConfiguration(
							"/**", config);
							returnsource; } }

You need to ensure that CorsFilteris ordered before the other filters, see this blog postabout how to configure Spring Boot accordingly.

Part VII. Integration

This part of the reference documentation covers the Spring Framework’s integration with a number of Java EE (and related) technologies.

28. Remoting and web services using Spring

28.1 Introduction

Spring features integration classes for remoting support using various technologies. The remoting support eases the development of remote-enabled services, implemented by your usual (Spring) POJOs. Currently, Spring supports the following remoting technologies:

  • Remote Method Invocation (RMI). Through the use of the RmiProxyFactoryBeanand the RmiServiceExporterSpring supports both traditional RMI (with java.rmi.Remoteinterfaces and java.rmi.RemoteException) and transparent remoting via RMI invokers (with any Java interface).
  • Spring’s HTTP invoker. Spring provides a special remoting strategy which allows for Java serialization via HTTP, supporting any Java interface (just like the RMI invoker). The corresponding support classes are HttpInvokerProxyFactoryBeanand HttpInvokerServiceExporter.
  • Hessian. By using Spring’s HessianProxyFactoryBeanand the HessianServiceExporteryou can transparently expose your services using the lightweight binary HTTP-based protocol provided by Caucho.
  • Burlap. Burlap is Caucho’s XML-based alternative to Hessian. Spring provides support classes such as BurlapProxyFactoryBeanand BurlapServiceExporter.
  • JAX-WS. Spring provides remoting support for web services via JAX-WS (the successor of JAX-RPC, as introduced in Java EE 5 and Java 6).
  • JMS. Remoting using JMS as the underlying protocol is supported via the JmsInvokerServiceExporterand JmsInvokerProxyFactoryBeanclasses.
  • AMQP. Remoting using AMQP as the underlying protocol is supported by the Spring AMQP project.

While discussing the remoting capabilities of Spring, we’ll use the following domain model and corresponding services:

							public
							classAccount
							implementsSerializable{
							privateString name;
							publicString getName(){
							returnname; }
							public
							voidsetName(String name) {
							this.name = name; } }
							public
							interfaceAccountService {
							public
							voidinsertAccount(Account account);
							publicList<Account> getAccounts(String name); }
							// the implementation doing nothing at the moment
							public
							classAccountServiceImpl
							implementsAccountService {
							public
							voidinsertAccount(Account acc) {
							// do something...}
							publicList<Account> getAccounts(String name) {
							// do something...} }

We will start exposing the service to a remote client by using RMI and talk a bit about the drawbacks of using RMI. We’ll then continue to show an example using Hessian as the protocol.

28.2 Exposing services using RMI

Using Spring’s support for RMI, you can transparently expose your services through the RMI infrastructure. After having this set up, you basically have a configuration similar to remote EJBs, except for the fact that there is no standard support for security context propagation or remote transaction propagation. Spring does provide hooks for such additional invocation context when using the RMI invoker, so you can for example plug in security frameworks or custom security credentials here.

28.2.1 Exporting the service using the RmiServiceExporter

Using the RmiServiceExporter, we can expose the interface of our AccountService object as RMI object. The interface can be accessed by using RmiProxyFactoryBean, or via plain RMI in case of a traditional RMI service. The RmiServiceExporterexplicitly supports the exposing of any non-RMI services via RMI invokers.

Of course, we first have to set up our service in the Spring container:

								<bean
								id=
								"accountService"
								class=
								"example.AccountServiceImpl"
								>
								<!-- any additional properties, maybe a DAO? -->
								</bean>

Next we’ll have to expose our service using the RmiServiceExporter:

								<bean
								class=
								"org.springframework.remoting.rmi.RmiServiceExporter"
								>
								<!-- does not necessarily have to be the same name as the bean to be exported -->
								<property
								name=
								"serviceName"
								value=
								"AccountService"
								/>
								<property
								name=
								"service"
								ref=
								"accountService"
								/>
								<property
								name=
								"serviceInterface"
								value=
								"example.AccountService"
								/>
								<!-- defaults to 1099 -->
								<property
								name=
								"registryPort"
								value=
								"1199"
								/>
								</bean>

As you can see, we’re overriding the port for the RMI registry. Often, your application server also maintains an RMI registry and it is wise to not interfere with that one. Furthermore, the service name is used to bind the service under. So right now, the service will be bound at 'rmi://HOST:1199/AccountService'. We’ll use the URL later on to link in the service at the client side.

[Note] Note

The servicePortproperty has been omitted (it defaults to 0). This means that an anonymous port will be used to communicate with the service.

28.2.2 Linking in the service at the client

Our client is a simple object using the AccountServiceto manage accounts:

								public
								classSimpleObject {
								privateAccountService accountService;
								public
								voidsetAccountService(AccountService accountService) {
								this.accountService = accountService; }
								// additional methods using the accountService}

To link in the service on the client, we’ll create a separate Spring container, containing the simple object and the service linking configuration bits:

								<bean
								class=
								"example.SimpleObject"
								>
								<property
								name=
								"accountService"
								ref=
								"accountService"
								/>
								</bean>
								<bean
								id=
								"accountService"
								class=
								"org.springframework.remoting.rmi.RmiProxyFactoryBean"
								>
								<property
								name=
								"serviceUrl"
								value=
								"rmi://HOST:1199/AccountService"
								/>
								<property
								name=
								"serviceInterface"
								value=
								"example.AccountService"
								/>
								</bean>

That’s all we need to do to support the remote account service on the client. Spring will transparently create an invoker and remotely enable the account service through the RmiServiceExporter. At the client we’re linking it in using the RmiProxyFactoryBean.

28.3 Using Hessian or Burlap to remotely call services via HTTP

Hessian offers a binary HTTP-based remoting protocol. It is developed by Caucho and more information about Hessian itself can be found at http://www.caucho.com.

28.3.1 Wiring up the DispatcherServlet for Hessian and co.

Hessian communicates via HTTP and does so using a custom servlet. Using Spring’s DispatcherServletprinciples, as known from Spring Web MVC usage, you can easily wire up such a servlet exposing your services. First we’ll have to create a new servlet in your application (this is an excerpt from 'web.xml'):

								<servlet>
								<servlet-name>remoting
								</servlet-name>
								<servlet-class>org.springframework.web.servlet.DispatcherServlet
								</servlet-class>
								<load-on-startup>1
								</load-on-startup>
								</servlet>
								<servlet-mapping>
								<servlet-name>remoting
								</servlet-name>
								<url-pattern>/remoting/*
								</url-pattern>
								</servlet-mapping>

You’re probably familiar with Spring’s DispatcherServletprinciples and if so, you know that now you’ll have to create a Spring container configuration resource named 'remoting-servlet.xml'(after the name of your servlet) in the 'WEB-INF'directory. The application context will be used in the next section.

Alternatively, consider the use of Spring’s simpler HttpRequestHandlerServlet. This allows you to embed the remote exporter definitions in your root application context (by default in 'WEB-INF/applicationContext.xml'), with individual servlet definitions pointing to specific exporter beans. Each servlet name needs to match the bean name of its target exporter in this case.

28.3.2 Exposing your beans by using the HessianServiceExporter

In the newly created application context called remoting-servlet.xml, we’ll create a HessianServiceExporterexporting your services:

								<bean
								id=
								"accountService"
								class=
								"example.AccountServiceImpl"
								>
								<!-- any additional properties, maybe a DAO? -->
								</bean>
								<bean
								name=
								"/AccountService"
								class=
								"org.springframework.remoting.caucho.HessianServiceExporter"
								>
								<property
								name=
								"service"
								ref=
								"accountService"
								/>
								<property
								name=
								"serviceInterface"
								value=
								"example.AccountService"
								/>
								</bean>

Now we’re ready to link in the service at the client. No explicit handler mapping is specified, mapping request URLs onto services, so BeanNameUrlHandlerMappingwill be used: Hence, the service will be exported at the URL indicated through its bean name within the containing DispatcherServlet’s mapping (as defined above): ’ http://HOST:8080/remoting/AccountService'.

Alternatively, create a HessianServiceExporterin your root application context (e.g. in 'WEB-INF/applicationContext.xml'):

								<bean
								name=
								"accountExporter"
								class=
								"org.springframework.remoting.caucho.HessianServiceExporter"
								>
								<property
								name=
								"service"
								ref=
								"accountService"
								/>
								<property
								name=
								"serviceInterface"
								value=
								"example.AccountService"
								/>
								</bean>

In the latter case, define a corresponding servlet for this exporter in 'web.xml', with the same end result: The exporter getting mapped to the request path /remoting/AccountService. Note that the servlet name needs to match the bean name of the target exporter.

								<servlet>
								<servlet-name>accountExporter
								</servlet-name>
								<servlet-class>org.springframework.web.context.support.HttpRequestHandlerServlet
								</servlet-class>
								</servlet>
								<servlet-mapping>
								<servlet-name>accountExporter
								</servlet-name>
								<url-pattern>/remoting/AccountService
								</url-pattern>
								</servlet-mapping>

28.3.3 Linking in the service on the client

Using the HessianProxyFactoryBeanwe can link in the service at the client. The same principles apply as with the RMI example. We’ll create a separate bean factory or application context and mention the following beans where the SimpleObjectis using the AccountServiceto manage accounts:

								<bean
								class=
								"example.SimpleObject"
								>
								<property
								name=
								"accountService"
								ref=
								"accountService"
								/>
								</bean>
								<bean
								id=
								"accountService"
								class=
								"org.springframework.remoting.caucho.HessianProxyFactoryBean"
								>
								<property
								name=
								"serviceUrl"
								value=
								"http://remotehost:8080/remoting/AccountService"
								/>
								<property
								name=
								"serviceInterface"
								value=
								"example.AccountService"
								/>
								</bean>

28.3.4 Using Burlap

We won’t discuss Burlap, the XML-based equivalent of Hessian, in detail here, since it is configured and set up in exactly the same way as the Hessian variant explained above. Just replace the word Hessianwith Burlapand you’re all set to go.

28.3.5 Applying HTTP basic authentication to a service exposed through Hessian or Burlap

One of the advantages of Hessian and Burlap is that we can easily apply HTTP basic authentication, because both protocols are HTTP-based. Your normal HTTP server security mechanism can easily be applied through using the web.xmlsecurity features, for example. Usually, you don’t use per-user security credentials here, but rather shared credentials defined at the Hessian/BurlapProxyFactoryBeanlevel (similar to a JDBC DataSource).

								<bean
								class=
								"org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping"
								>
								<property
								name=
								"interceptors"
								ref=
								"authorizationInterceptor"
								/>
								</bean>
								<bean
								id=
								"authorizationInterceptor"
								class=
								"org.springframework.web.servlet.handler.UserRoleAuthorizationInterceptor"
								>
								<property
								name=
								"authorizedRoles"
								value=
								"administrator,operator"
								/>
								</bean>

This is an example where we explicitly mention the BeanNameUrlHandlerMappingand set an interceptor allowing only administrators and operators to call the beans mentioned in this application context.

[Note] Note

Of course, this example doesn’t show a flexible kind of security infrastructure. For more options as far as security is concerned, have a look at the Spring Security project at http://projects.spring.io/spring-security/.

28.4 Exposing services using HTTP invokers

As opposed to Burlap and Hessian, which are both lightweight protocols using their own slim serialization mechanisms, Spring HTTP invokers use the standard Java serialization mechanism to expose services through HTTP. This has a huge advantage if your arguments and return types are complex types that cannot be serialized using the serialization mechanisms Hessian and Burlap use (refer to the next section for more considerations when choosing a remoting technology).

Under the hood, Spring uses either the standard facilities provided by the JDK or Apache HttpComponentsto perform HTTP calls. Use the latter if you need more advanced and easier-to-use functionality. Refer to hc.apache.org/httpcomponents-client-ga/for more information.

28.4.1 Exposing the service object

Setting up the HTTP invoker infrastructure for a service object resembles closely the way you would do the same using Hessian or Burlap. Just as Hessian support provides the HessianServiceExporter, Spring’s HttpInvoker support provides the org.springframework.remoting.httpinvoker.HttpInvokerServiceExporter.

To expose the AccountService(mentioned above) within a Spring Web MVC DispatcherServlet, the following configuration needs to be in place in the dispatcher’s application context:

								<bean
								name=
								"/AccountService"
								class=
								"org.springframework.remoting.httpinvoker.HttpInvokerServiceExporter"
								>
								<property
								name=
								"service"
								ref=
								"accountService"
								/>
								<property
								name=
								"serviceInterface"
								value=
								"example.AccountService"
								/>
								</bean>

Such an exporter definition will be exposed through the `DispatcherServlet’s standard mapping facilities, as explained in the section on Hessian.

Alternatively, create an HttpInvokerServiceExporterin your root application context (e.g. in 'WEB-INF/applicationContext.xml'):

								<bean
								name=
								"accountExporter"
								class=
								"org.springframework.remoting.httpinvoker.HttpInvokerServiceExporter"
								>
								<property
								name=
								"service"
								ref=
								"accountService"
								/>
								<property
								name=
								"serviceInterface"
								value=
								"example.AccountService"
								/>
								</bean>

In addition, define a corresponding servlet for this exporter in 'web.xml', with the servlet name matching the bean name of the target exporter:

								<servlet>
								<servlet-name>accountExporter
								</servlet-name>
								<servlet-class>org.springframework.web.context.support.HttpRequestHandlerServlet
								</servlet-class>
								</servlet>
								<servlet-mapping>
								<servlet-name>accountExporter
								</servlet-name>
								<url-pattern>/remoting/AccountService
								</url-pattern>
								</servlet-mapping>

If you are running outside of a servlet container and are using Oracle’s Java 6, then you can use the built-in HTTP server implementation. You can configure the SimpleHttpServerFactoryBeantogether with a SimpleHttpInvokerServiceExporteras is shown in this example:

								<bean
								name=
								"accountExporter"
								class=
								"org.springframework.remoting.httpinvoker.SimpleHttpInvokerServiceExporter"
								>
								<property
								name=
								"service"
								ref=
								"accountService"
								/>
								<property
								name=
								"serviceInterface"
								value=
								"example.AccountService"
								/>
								</bean>
								<bean
								id=
								"httpServer"
								class=
								"org.springframework.remoting.support.SimpleHttpServerFactoryBean"
								>
								<property
								name=
								"contexts"
								>
								<util:map>
								<entry
								key=
								"/remoting/AccountService"
								value-ref=
								"accountExporter"
								/>
								</util:map>
								</property>
								<property
								name=
								"port"
								value=
								"8080"
								/>
								</bean>

28.4.2 Linking in the service at the client

Again, linking in the service from the client much resembles the way you would do it when using Hessian or Burlap. Using a proxy, Spring will be able to translate your calls to HTTP POST requests to the URL pointing to the exported service.

								<bean
								id=
								"httpInvokerProxy"
								class=
								"org.springframework.remoting.httpinvoker.HttpInvokerProxyFactoryBean"
								>
								<property
								name=
								"serviceUrl"
								value=
								"http://remotehost:8080/remoting/AccountService"
								/>
								<property
								name=
								"serviceInterface"
								value=
								"example.AccountService"
								/>
								</bean>

As mentioned before, you can choose what HTTP client you want to use. By default, the HttpInvokerProxyuses the JDK’s HTTP functionality, but you can also use the Apache HttpComponentsclient by setting the httpInvokerRequestExecutorproperty:

								<property
								name=
								"httpInvokerRequestExecutor"
								>
								<bean
								class=
								"org.springframework.remoting.httpinvoker.HttpComponentsHttpInvokerRequestExecutor"
								/>
								</property>

28.5 Web services

Spring provides full support for standard Java web services APIs:

  • Exposing web services using JAX-WS
  • Accessing web services using JAX-WS

In addition to stock support for JAX-WS in Spring Core, the Spring portfolio also features Spring Web Services, a solution for contract-first, document-driven web services - highly recommended for building modern, future-proof web services.

28.5.1 Exposing servlet-based web services using JAX-WS

Spring provides a convenient base class for JAX-WS servlet endpoint implementations - SpringBeanAutowiringSupport. To expose our AccountServicewe extend Spring’s SpringBeanAutowiringSupportclass and implement our business logic here, usually delegating the call to the business layer. We’ll simply use Spring’s @Autowiredannotation for expressing such dependencies on Spring-managed beans.

								/** * JAX-WS compliant AccountService implementation that simply delegates * to the AccountService implementation in the root web application context. * * This wrapper class is necessary because JAX-WS requires working with dedicated * endpoint classes. If an existing service needs to be exported, a wrapper that * extends SpringBeanAutowiringSupport for simple Spring bean autowiring (through * the @Autowired annotation) is the simplest JAX-WS compliant way. * * This is the class registered with the server-side JAX-WS implementation. * In the case of a Java EE 5 server, this would simply be defined as a servlet * in web.xml, with the server detecting that this is a JAX-WS endpoint and reacting * accordingly. The servlet name usually needs to match the specified WS service name. * * The web service engine manages the lifecycle of instances of this class. * Spring bean references will just be wired in here. */
								importorg.springframework.web.context.support.SpringBeanAutowiringSupport;
								
									@WebService(serviceName="AccountService")
								public
								classAccountServiceEndpoint
								extendsSpringBeanAutowiringSupport {
								
									@Autowired
								privateAccountService biz;
								
									@WebMethod
								public
								voidinsertAccount(Account acc) { biz.insertAccount(acc); }
								
									@WebMethod
								publicAccount[] getAccounts(String name) {
								returnbiz.getAccounts(name); } }

Our AccountServiceEndpointneeds to run in the same web application as the Spring context to allow for access to Spring’s facilities. This is the case by default in Java EE 5 environments, using the standard contract for JAX-WS servlet endpoint deployment. See Java EE 5 web service tutorials for details.

28.5.2 Exporting standalone web services using JAX-WS

The built-in JAX-WS provider that comes with Oracle’s JDK 1.6 supports exposure of web services using the built-in HTTP server that’s included in JDK 1.6 as well. Spring’s SimpleJaxWsServiceExporterdetects all @WebServiceannotated beans in the Spring application context, exporting them through the default JAX-WS server (the JDK 1.6 HTTP server).

In this scenario, the endpoint instances are defined and managed as Spring beans themselves; they will be registered with the JAX-WS engine but their lifecycle will be up to the Spring application context. This means that Spring functionality like explicit dependency injection may be applied to the endpoint instances. Of course, annotation-driven injection through @Autowiredwill work as well.

								<bean
								class=
								"org.springframework.remoting.jaxws.SimpleJaxWsServiceExporter"
								>
								<property
								name=
								"baseAddress"
								value=
								"http://localhost:8080/"
								/>
								</bean>
								<bean
								id=
								"accountServiceEndpoint"
								class=
								"example.AccountServiceEndpoint"
								>...
								</bean>...

The AccountServiceEndpointmay derive from Spring’s SpringBeanAutowiringSupportbut doesn’t have to since the endpoint is a fully Spring-managed bean here. This means that the endpoint implementation may look like as follows, without any superclass declared - and Spring’s @Autowiredconfiguration annotation still being honored:

								
									@WebService(serviceName="AccountService")
								public
								classAccountServiceEndpoint {
								
									@Autowired
								privateAccountService biz;
								
									@WebMethod
								public
								voidinsertAccount(Account acc) { biz.insertAccount(acc); }
								
									@WebMethod
								publicList<Account> getAccounts(String name) {
								returnbiz.getAccounts(name); } }

28.5.3 Exporting web services using the JAX-WS RI’s Spring support

Oracle’s JAX-WS RI, developed as part of the GlassFish project, ships Spring support as part of its JAX-WS Commons project. This allows for defining JAX-WS endpoints as Spring-managed beans, similar to the standalone mode discussed in the previous section - but this time in a Servlet environment. Note that this is not portable in a Java EE 5 environment; it is mainly intended for non-EE environments such as Tomcat, embedding the JAX-WS RI as part of the web application.

The difference to the standard style of exporting servlet-based endpoints is that the lifecycle of the endpoint instances themselves will be managed by Spring here, and that there will be only one JAX-WS servlet defined in web.xml. With the standard Java EE 5 style (as illustrated above), you’ll have one servlet definition per service endpoint, with each endpoint typically delegating to Spring beans (through the use of @Autowired, as shown above).

Check out https://jax-ws-commons.java.net/spring/for details on setup and usage style.

28.5.4 Accessing web services using JAX-WS

Spring provides two factory beans to create JAX-WS web service proxies, namely LocalJaxWsServiceFactoryBeanand JaxWsPortProxyFactoryBean. The former can only return a JAX-WS service class for us to work with. The latter is the full-fledged version that can return a proxy that implements our business service interface. In this example we use the latter to create a proxy for the AccountServiceendpoint (again):

								<bean
								id=
								"accountWebService"
								class=
								"org.springframework.remoting.jaxws.JaxWsPortProxyFactoryBean"
								>
								<property
								name=
								"serviceInterface"
								value=
								"example.AccountService"
								/>
								<property
								name=
								"wsdlDocumentUrl"
								value=
								"http://localhost:8888/AccountServiceEndpoint?WSDL"
								/>
								<property
								name=
								"namespaceUri"
								value=
								"http://example/"
								/>
								<property
								name=
								"serviceName"
								value=
								"AccountService"
								/>
								<property
								name=
								"portName"
								value=
								"AccountServiceEndpointPort"
								/>
								</bean>

Where serviceInterfaceis our business interface the clients will use. wsdlDocumentUrlis the URL for the WSDL file. Spring needs this a startup time to create the JAX-WS Service. namespaceUricorresponds to the targetNamespace in the .wsdl file. serviceNamecorresponds to the service name in the .wsdl file. portNamecorresponds to the port name in the .wsdl file.

Accessing the web service is now very easy as we have a bean factory for it that will expose it as AccountServiceinterface. We can wire this up in Spring:

								<bean
								id=
								"client"
								class=
								"example.AccountClientImpl"
								>...
								<property
								name=
								"service"
								ref=
								"accountWebService"
								/>
								</bean>

From the client code we can access the web service just as if it was a normal class:

								public
								classAccountClientImpl {
								privateAccountService service;
								public
								voidsetService(AccountService service) {
								this.service = service; }
								public
								voidfoo() { service.insertAccount(...); } }
[Note] Note

The above is slightly simplified in that JAX-WS requires endpoint interfaces and implementation classes to be annotated with @WebService, @SOAPBindingetc annotations. This means that you cannot (easily) use plain Java interfaces and implementation classes as JAX-WS endpoint artifacts; you need to annotate them accordingly first. Check the JAX-WS documentation for details on those requirements.

28.6 JMS

It is also possible to expose services transparently using JMS as the underlying communication protocol. The JMS remoting support in the Spring Framework is pretty basic - it sends and receives on the same threadand in the same non-transactional Session, and as such throughput will be very implementation dependent. Note that these single-threaded and non-transactional constraints apply only to Spring’s JMS remotingsupport. See Chapter 30, JMS (Java Message Service) for information on Spring’s rich support for JMS-based messaging.

The following interface is used on both the server and the client side.

							packagecom.foo;
							public
							interfaceCheckingAccountService {
							public
							voidcancelAccount(Long accountId); }

The following simple implementation of the above interface is used on the server-side.

							packagecom.foo;
							public
							classSimpleCheckingAccountService
							implementsCheckingAccountService {
							public
							voidcancelAccount(Long accountId) { System.out.println(
							"Cancelling account ["+ accountId +
							"]"); } }

This configuration file contains the JMS-infrastructure beans that are shared on both the client and server.

							<?xml version="1.0" encoding="UTF-8"?>
							<beans
							xmlns=
							"http://www.springframework.org/schema/beans"
							xmlns:xsi=
							"http://www.w3.org/2001/XMLSchema-instance"
							xsi:schemaLocation=
							"http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd"
							>
							<bean
							id=
							"connectionFactory"
							class=
							"org.apache.activemq.ActiveMQConnectionFactory"
							>
							<property
							name=
							"brokerURL"
							value=
							"tcp://ep-t43:61616"
							/>
							</bean>
							<bean
							id=
							"queue"
							class=
							"org.apache.activemq.command.ActiveMQQueue"
							>
							<constructor-arg
							value=
							"mmm"
							/>
							</bean>
							</beans>

28.6.1 Server-side configuration

On the server, you just need to expose the service object using the JmsInvokerServiceExporter.

								<?xml version="1.0" encoding="UTF-8"?>
								<beans
								xmlns=
								"http://www.springframework.org/schema/beans"
								xmlns:xsi=
								"http://www.w3.org/2001/XMLSchema-instance"
								xsi:schemaLocation=
								"http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd"
								>
								<bean
								id=
								"checkingAccountService"
								class=
								"org.springframework.jms.remoting.JmsInvokerServiceExporter"
								>
								<property
								name=
								"serviceInterface"
								value=
								"com.foo.CheckingAccountService"
								/>
								<property
								name=
								"service"
								>
								<bean
								class=
								"com.foo.SimpleCheckingAccountService"
								/>
								</property>
								</bean>
								<bean
								class=
								"org.springframework.jms.listener.SimpleMessageListenerContainer"
								>
								<property
								name=
								"connectionFactory"
								ref=
								"connectionFactory"
								/>
								<property
								name=
								"destination"
								ref=
								"queue"
								/>
								<property
								name=
								"concurrentConsumers"
								value=
								"3"
								/>
								<property
								name=
								"messageListener"
								ref=
								"checkingAccountService"
								/>
								</bean>
								</beans>
								packagecom.foo;
								importorg.springframework.context.support.ClassPathXmlApplicationContext;
								public
								classServer {
								public
								static
								voidmain(String[] args)
								throwsException {
								newClassPathXmlApplicationContext(
								newString[]{
								"com/foo/server.xml",
								"com/foo/jms.xml"}); } }

28.6.2 Client-side configuration

The client merely needs to create a client-side proxy that will implement the agreed upon interface ( CheckingAccountService). The resulting object created off the back of the following bean definition can be injected into other client side objects, and the proxy will take care of forwarding the call to the server-side object via JMS.

								<?xml version="1.0" encoding="UTF-8"?>
								<beans
								xmlns=
								"http://www.springframework.org/schema/beans"
								xmlns:xsi=
								"http://www.w3.org/2001/XMLSchema-instance"
								xsi:schemaLocation=
								"http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd"
								>
								<bean
								id=
								"checkingAccountService"
								class=
								"org.springframework.jms.remoting.JmsInvokerProxyFactoryBean"
								>
								<property
								name=
								"serviceInterface"
								value=
								"com.foo.CheckingAccountService"
								/>
								<property
								name=
								"connectionFactory"
								ref=
								"connectionFactory"
								/>
								<property
								name=
								"queue"
								ref=
								"queue"
								/>
								</bean>
								</beans>
								packagecom.foo;
								importorg.springframework.context.ApplicationContext;
								importorg.springframework.context.support.ClassPathXmlApplicationContext;
								public
								classClient {
								public
								static
								voidmain(String[] args)
								throwsException { ApplicationContext ctx =
								newClassPathXmlApplicationContext(
								newString[] {
								"com/foo/client.xml",
								"com/foo/jms.xml"}); CheckingAccountService service = (CheckingAccountService) ctx.getBean(
								"checkingAccountService"); service.cancelAccount(
								newLong(
								10)); } }

28.7 AMQP

Refer to the Spring AMQP Reference Document 'Spring Remoting with AMQP' sectionfor more information.

28.8 Auto-detection is not implemented for remote interfaces

The main reason why auto-detection of implemented interfaces does not occur for remote interfaces is to avoid opening too many doors to remote callers. The target object might implement internal callback interfaces like InitializingBeanor DisposableBeanwhich one would not want to expose to callers.

Offering a proxy with all interfaces implemented by the target usually does not matter in the local case. But when exporting a remote service, you should expose a specific service interface, with specific operations intended for remote usage. Besides internal callback interfaces, the target might implement multiple business interfaces, with just one of them intended for remote exposure. For these reasons, we requiresuch a service interface to be specified.

This is a trade-off between configuration convenience and the risk of accidental exposure of internal methods. Always specifying a service interface is not too much effort, and puts you on the safe side regarding controlled exposure of specific methods.

28.9 Considerations when choosing a technology

Each and every technology presented here has its drawbacks. You should carefully consider your needs, the services you are exposing and the objects you’ll be sending over the wire when choosing a technology.

When using RMI, it’s not possible to access the objects through the HTTP protocol, unless you’re tunneling the RMI traffic. RMI is a fairly heavy-weight protocol in that it supports full-object serialization which is important when using a complex data model that needs serialization over the wire. However, RMI-JRMP is tied to Java clients: It is a Java-to-Java remoting solution.

Spring’s HTTP invoker is a good choice if you need HTTP-based remoting but also rely on Java serialization. It shares the basic infrastructure with RMI invokers, just using HTTP as transport. Note that HTTP invokers are not only limited to Java-to-Java remoting but also to Spring on both the client and server side. (The latter also applies to Spring’s RMI invoker for non-RMI interfaces.)

Hessian and/or Burlap might provide significant value when operating in a heterogeneous environment, because they explicitly allow for non-Java clients. However, non-Java support is still limited. Known issues include the serialization of Hibernate objects in combination with lazily-initialized collections. If you have such a data model, consider using RMI or HTTP invokers instead of Hessian.

JMS can be useful for providing clusters of services and allowing the JMS broker to take care of load balancing, discovery and auto-failover. By default: Java serialization is used when using JMS remoting but the JMS provider could use a different mechanism for the wire formatting, such as XStream to allow servers to be implemented in other technologies.

Last but not least, EJB has an advantage over RMI in that it supports standard role-based authentication and authorization and remote transaction propagation. It is possible to get RMI invokers or HTTP invokers to support security context propagation as well, although this is not provided by core Spring: There are just appropriate hooks for plugging in third-party or custom solutions here.

28.10 Accessing RESTful services on the Client

The RestTemplateis the core class for client-side access to RESTful services. It is conceptually similar to other template classes in Spring, such as JdbcTemplateand JmsTemplateand other template classes found in other Spring portfolio projects. RestTemplate’s behavior is customized by providing callback methods and configuring the `HttpMessageConverterused to marshal objects into the HTTP request body and to unmarshal any response back into an object. As it is common to use XML as a message format, Spring provides a MarshallingHttpMessageConverterthat uses the Object-to-XML framework that is part of the org.springframework.oxmpackage. This gives you a wide range of choices of XML to Object mapping technologies to choose from.

This section describes how to use the RestTemplateand its associated HttpMessageConverters.

28.10.1 RestTemplate

Invoking RESTful services in Java is typically done using a helper class such as Apache HttpComponents HttpClient. For common REST operations this approach is too low level as shown below.

String uri =
								"http://example.com/hotels/1/bookings"; PostMethod post =
								newPostMethod(uri); String request =
								// create booking request contentpost.setRequestEntity(
								newStringRequestEntity(request)); httpClient.executeMethod(post);
								if(HttpStatus.SC_CREATED == post.getStatusCode()) { Header location = post.getRequestHeader(
								"Location");
								if(location != null) { System.out.println(
								"Created new booking at :"+ location.getValue()); } }

RestTemplate provides higher level methods that correspond to each of the six main HTTP methods that make invoking many RESTful services a one-liner and enforce REST best practices.

[Note] Note

RestTemplate has an asynchronous counter-part: see Section 28.10.3, “Async RestTemplate”.

Table 28.1. Overview of RestTemplate methods

HTTP Method RestTemplate Method

DELETE

delete

GET

getForObject getForEntity

HEAD

headForHeaders(String url, String…​ urlVariables)

OPTIONS

optionsForAllow(String url, String…​ urlVariables)

POST

postForLocation(String url, Object request, String…​ urlVariables) postForObject(String url, Object request, Class<T> responseType, String…​ uriVariables)

PUT

put(String url, Object request, String…​urlVariables)

PATCH and others

exchange execute

The names of RestTemplatemethods follow a naming convention, the first part indicates what HTTP method is being invoked and the second part indicates what is returned. For example, the method getForObject()will perform a GET, convert the HTTP response into an object type of your choice and return that object. The method postForLocation()will do a POST, converting the given object into a HTTP request and return the response HTTP Location header where the newly created object can be found. In case of an exception processing the HTTP request, an exception of the type RestClientExceptionwill be thrown; this behavior can be changed by plugging in another ResponseErrorHandlerimplementation into the RestTemplate.

The exchangeand executemethods are generalized versions of the more specific methods listed above them and can support additional combinations and methods, like HTTP PATCH. However, note that the underlying HTTP library must also support the desired combination. The JDK HttpURLConnectiondoes not support the PATCHmethod, but Apache HttpComponents HttpClient version 4.2 or later does. They also enable RestTemplateto read an HTTP response to a generic type (e.g. List<Account>), using a ParameterizedTypeReference, a new class that enables capturing and passing generic type info.

Objects passed to and returned from these methods are converted to and from HTTP messages by HttpMessageConverterinstances. Converters for the main mime types are registered by default, but you can also write your own converter and register it via the messageConverters()bean property. The default converter instances registered with the template are ByteArrayHttpMessageConverter, StringHttpMessageConverter, FormHttpMessageConverterand SourceHttpMessageConverter. You can override these defaults using the messageConverters()bean property as would be required if using the MarshallingHttpMessageConverteror MappingJackson2HttpMessageConverter.

Each method takes URI template arguments in two forms, either as a Stringvariable length argument or a Map<String,String>. For example,

String result = restTemplate.getForObject(
								"http://example.com/hotels/{hotel}/bookings/{booking}", String.
								class,
								"42",
								"21");

using variable length arguments and

Map<String, String> vars = Collections.singletonMap(
								"hotel",
								"42"); String result = restTemplate.getForObject(
								"http://example.com/hotels/{hotel}/rooms/{hotel}", String.
								class, vars);

using a Map<String,String>.

To create an instance of RestTemplateyou can simply call the default no-arg constructor. This will use standard Java classes from the java.netpackage as the underlying implementation to create HTTP requests. This can be overridden by specifying an implementation of ClientHttpRequestFactory. Spring provides the implementation HttpComponentsClientHttpRequestFactorythat uses the Apache HttpComponents HttpClientto create requests. HttpComponentsClientHttpRequestFactoryis configured using an instance of org.apache.http.client.HttpClientwhich can in turn be configured with credentials information or connection pooling functionality.

[Tip] Tip

Note that the java.netimplementation for HTTP requests may raise an exception when accessing the status of a response that represents an error (e.g. 401). If this is an issue, switch to HttpComponentsClientHttpRequestFactoryinstead.

The previous example using Apache HttpComponents HttpClientdirectly rewritten to use the RestTemplateis shown below

uri =
								"http://example.com/hotels/{id}/bookings"; RestTemplate template =
								newRestTemplate(); Booking booking =
								// create booking objectURI location = template.postForLocation(uri, booking,
								"1");

To use Apache HttpComponents instead of the native java.netfunctionality, construct the RestTemplateas follows:

RestTemplate template =
								newRestTemplate(
								newHttpComponentsClientHttpRequestFactory());
[Tip] Tip

Apache HttpClient supports gzip encoding. To use it, construct a HttpComponentsClientHttpRequestFactorylike so:

HttpClient httpClient = HttpClientBuilder.create().build(); ClientHttpRequestFactory requestFactory =
												newHttpComponentsClientHttpRequestFactory(httpClient); RestTemplate restTemplate =
												newRestTemplate(requestFactory);

The general callback interface is RequestCallbackand is called when the execute method is invoked.

								public<T> T execute(String url, HttpMethod method, RequestCallback requestCallback, ResponseExtractor<T> responseExtractor, String... urlVariables)
								// also has an overload with urlVariables as a Map<String, String>.

The RequestCallbackinterface is defined as

								public
								interfaceRequestCallback {
								voiddoWithRequest(ClientHttpRequest request)
								throwsIOException; }

and allows you to manipulate the request headers and write to the request body. When using the execute method you do not have to worry about any resource management, the template will always close the request and handle any errors. Refer to the API documentation for more information on using the execute method and the meaning of its other method arguments.

Working with the URI

For each of the main HTTP methods, the RestTemplateprovides variants that either take a String URI or java.net.URIas the first argument.

The String URI variants accept template arguments as a String variable length argument or as a Map<String,String>. They also assume the URL String is not encoded and needs to be encoded. For example the following:

restTemplate.getForObject(
									"http://example.com/hotel list", String.
									class);

will perform a GET on http://example.com/hotel%20list. That means if the input URL String is already encoded, it will be encoded twice — i.e. http://example.com/hotel%20listwill become http://example.com/hotel%2520list. If this is not the intended effect, use the java.net.URImethod variant, which assumes the URL is already encoded is also generally useful if you want to reuse a single (fully expanded) URImultiple times.

The UriComponentsBuilderclass can be used to build and encode the URIincluding support for URI templates. For example you can start with a URL String:

UriComponents uriComponents = UriComponentsBuilder.fromUriString(
									"http://example.com/hotels/{hotel}/bookings/{booking}").build() .expand(
									"42",
									"21") .encode(); URI uri = uriComponents.toUri();

Or specify each URI component individually:

UriComponents uriComponents = UriComponentsBuilder.newInstance() .scheme(
									"http").host(
									"example.com").path(
									"/hotels/{hotel}/bookings/{booking}").build() .expand(
									"42",
									"21") .encode(); URI uri = uriComponents.toUri();

Dealing with request and response headers

Besides the methods described above, the RestTemplatealso has the exchange()method, which can be used for arbitrary HTTP method execution based on the HttpEntityclass.

Perhaps most importantly, the exchange()method can be used to add request headers and read response headers. For example:

HttpHeaders requestHeaders =
									newHttpHeaders(); requestHeaders.set(
									"MyRequestHeader",
									"MyValue"); HttpEntity<?> requestEntity =
									newHttpEntity(requestHeaders); HttpEntity<String> response = template.exchange(
									"http://example.com/hotels/{hotel}", HttpMethod.GET, requestEntity, String.
									class,
									"42"); String responseHeader = response.getHeaders().getFirst(
									"MyResponseHeader"); String body = response.getBody();

In the above example, we first prepare a request entity that contains the MyRequestHeaderheader. We then retrieve the response, and read the MyResponseHeaderand body.

Jackson JSON Views support

It is possible to specify a Jackson JSON Viewto serialize only a subset of the object properties. For example:

MappingJacksonValue value =
									newMappingJacksonValue(
									newUser(
									"eric",
									"7!jd#h23")); value.setSerializationView(User.WithoutPasswordView.
									class); HttpEntity<MappingJacksonValue> entity =
									newHttpEntity<MappingJacksonValue>(value); String s = template.postForObject(
									"http://example.com/user", entity, String.
									class);

28.10.2 HTTP Message Conversion

Objects passed to and returned from the methods getForObject(), postForLocation(), and put()are converted to HTTP requests and from HTTP responses by HttpMessageConverters. The HttpMessageConverterinterface is shown below to give you a better feel for its functionality

								public
								interfaceHttpMessageConverter<T> {
								// Indicate whether the given class and media type can be read by this converter.
								booleancanRead(Class<?> clazz, MediaType mediaType);
								// Indicate whether the given class and media type can be written by this converter.
								booleancanWrite(Class<?> clazz, MediaType mediaType);
								// Return the list of MediaType objects supported by this converter.List<MediaType> getSupportedMediaTypes();
								// Read an object of the given type from the given input message, and returns it.T read(Class<T> clazz, HttpInputMessage inputMessage)
								throwsIOException, HttpMessageNotReadableException;
								// Write an given object to the given output message.
								voidwrite(T t, HttpOutputMessage outputMessage)
								throwsIOException, HttpMessageNotWritableException; }

Concrete implementations for the main media (mime) types are provided in the framework and are registered by default with the RestTemplateon the client-side and with AnnotationMethodHandlerAdapteron the server-side.

The implementations of HttpMessageConverters are described in the following sections. For all converters a default media type is used but can be overridden by setting the supportedMediaTypesbean property

StringHttpMessageConverter

An HttpMessageConverterimplementation that can read and write Strings from the HTTP request and response. By default, this converter supports all text media types ( text/*), and writes with a Content-Typeof text/plain.

FormHttpMessageConverter

An HttpMessageConverterimplementation that can read and write form data from the HTTP request and response. By default, this converter reads and writes the media type application/x-www-form-urlencoded. Form data is read from and written into a MultiValueMap<String, String>.

ByteArrayHttpMessageConverter

An HttpMessageConverterimplementation that can read and write byte arrays from the HTTP request and response. By default, this converter supports all media types ( */*), and writes with a Content-Typeof application/octet-stream. This can be overridden by setting the supportedMediaTypesproperty, and overriding getContentType(byte[]).

MarshallingHttpMessageConverter

An HttpMessageConverterimplementation that can read and write XML using Spring’s Marshallerand Unmarshallerabstractions from the org.springframework.oxmpackage. This converter requires a Marshallerand Unmarshallerbefore it can be used. These can be injected via constructor or bean properties. By default this converter supports ( text/xml) and ( application/xml).

MappingJackson2HttpMessageConverter

An HttpMessageConverterimplementation that can read and write JSON using Jackson’s ObjectMapper. JSON mapping can be customized as needed through the use of Jackson’s provided annotations. When further control is needed, a custom ObjectMappercan be injected through the ObjectMapperproperty for cases where custom JSON serializers/deserializers need to be provided for specific types. By default this converter supports ( application/json).

MappingJackson2XmlHttpMessageConverter

An HttpMessageConverterimplementation that can read and write XML using Jackson XMLextension’s XmlMapper. XML mapping can be customized as needed through the use of JAXB or Jackson’s provided annotations. When further control is needed, a custom XmlMappercan be injected through the ObjectMapperproperty for cases where custom XML serializers/deserializers need to be provided for specific types. By default this converter supports ( application/xml).

SourceHttpMessageConverter

An HttpMessageConverterimplementation that can read and write javax.xml.transform.Sourcefrom the HTTP request and response. Only DOMSource, SAXSource, and StreamSourceare supported. By default, this converter supports ( text/xml) and ( application/xml).

BufferedImageHttpMessageConverter

An HttpMessageConverterimplementation that can read and write java.awt.image.BufferedImagefrom the HTTP request and response. This converter reads and writes the media type supported by the Java I/O API.

28.10.3 Async RestTemplate

Web applications often need to query external REST services those days. The very nature of HTTP and synchronous calls can lead up to challenges when scaling applications for those needs: multiple threads may be blocked, waiting for remote HTTP responses.

AsyncRestTemplateand Section 28.10.1, “RestTemplate”'s APIs are very similar; see Table 28.1, “Overview of RestTemplate methods”. The main difference between those APIs is that AsyncRestTemplatereturns ListenableFuturewrappers as opposed to concrete results.

The previous RestTemplateexample translates to:

								// async callFuture<ResponseEntity<String>> futureEntity = template.getForEntity(
								"http://example.com/hotels/{hotel}/bookings/{booking}", String.
								class,
								"42",
								"21");
								// get the concrete result - synchronous callResponseEntity<String> entity = futureEntity.get();

ListenableFutureaccepts completion callbacks:

ListenableFuture<ResponseEntity<String>> futureEntity = template.getForEntity(
								"http://example.com/hotels/{hotel}/bookings/{booking}", String.
								class,
								"42",
								"21");
								// register a callbackfutureEntity.addCallback(
								newListenableFutureCallback<ResponseEntity<String>>() {
								
									@Override
								public
								voidonSuccess(ResponseEntity<String> entity) {
								//...}
								
									@Override
								public
								voidonFailure(Throwable t) {
								//...} });
[Note] Note

The default AsyncRestTemplateconstructor registers a SimpleAsyncTaskExecutorfor executing HTTP requests. When dealing with a large number of short-lived requests, a thread-pooling TaskExecutor implementation like ThreadPoolTaskExecutormay be a good choice.

See the ListenableFuturejavadocsand AsyncRestTemplatejavadocsfor more details.

29. Enterprise JavaBeans (EJB) integration

29.1 Introduction

As a lightweight container, Spring is often considered an EJB replacement. We do believe that for many if not most applications and use cases, Spring as a container, combined with its rich supporting functionality in the area of transactions, ORM and JDBC access, is a better choice than implementing equivalent functionality via an EJB container and EJBs.

However, it is important to note that using Spring does not prevent you from using EJBs. In fact, Spring makes it much easier to access EJBs and implement EJBs and functionality within them. Additionally, using Spring to access services provided by EJBs allows the implementation of those services to later transparently be switched between local EJB, remote EJB, or POJO (plain old Java object) variants, without the client code having to be changed.

In this chapter, we look at how Spring can help you access and implement EJBs. Spring provides particular value when accessing stateless session beans (SLSBs), so we’ll begin by discussing this.

29.2 Accessing EJBs

29.2.1 Concepts

To invoke a method on a local or remote stateless session bean, client code must normally perform a JNDI lookup to obtain the (local or remote) EJB Home object, then use a 'create' method call on that object to obtain the actual (local or remote) EJB object. One or more methods are then invoked on the EJB.

To avoid repeated low-level code, many EJB applications use the Service Locator and Business Delegate patterns. These are better than spraying JNDI lookups throughout client code, but their usual implementations have significant disadvantages. For example:

  • Typically code using EJBs depends on Service Locator or Business Delegate singletons, making it hard to test.
  • In the case of the Service Locator pattern used without a Business Delegate, application code still ends up having to invoke the create() method on an EJB home, and deal with the resulting exceptions. Thus it remains tied to the EJB API and the complexity of the EJB programming model.
  • Implementing the Business Delegate pattern typically results in significant code duplication, where we have to write numerous methods that simply call the same method on the EJB.

The Spring approach is to allow the creation and use of proxy objects, normally configured inside a Spring container, which act as codeless business delegates. You do not need to write another Service Locator, another JNDI lookup, or duplicate methods in a hand-coded Business Delegate unless you are actually adding real value in such code.

29.2.2 Accessing local SLSBs

Assume that we have a web controller that needs to use a local EJB. We’ll follow best practice and use the EJB Business Methods Interface pattern, so that the EJB’s local interface extends a non EJB-specific business methods interface. Let’s call this business methods interface MyComponent.

								public
								interfaceMyComponent { ... }

One of the main reasons to use the Business Methods Interface pattern is to ensure that synchronization between method signatures in local interface and bean implementation class is automatic. Another reason is that it later makes it much easier for us to switch to a POJO (plain old Java object) implementation of the service if it makes sense to do so. Of course we’ll also need to implement the local home interface and provide an implementation class that implements SessionBeanand the MyComponentbusiness methods interface. Now the only Java coding we’ll need to do to hook up our web tier controller to the EJB implementation is to expose a setter method of type MyComponenton the controller. This will save the reference as an instance variable in the controller:

								privateMyComponent myComponent;
								public
								voidsetMyComponent(MyComponent myComponent) {
								this.myComponent = myComponent; }

We can subsequently use this instance variable in any business method in the controller. Now assuming we are obtaining our controller object out of a Spring container, we can (in the same context) configure a LocalStatelessSessionProxyFactoryBeaninstance, which will be the EJB proxy object. The configuration of the proxy, and setting of the myComponentproperty of the controller is done with a configuration entry such as:

								<bean
								id=
								"myComponent"
								class=
								"org.springframework.ejb.access.LocalStatelessSessionProxyFactoryBean"
								>
								<property
								name=
								"jndiName"
								value=
								"ejb/myBean"
								/>
								<property
								name=
								"businessInterface"
								value=
								"com.mycom.MyComponent"
								/>
								</bean>
								<bean
								id=
								"myController"
								class=
								"com.mycom.myController"
								>
								<property
								name=
								"myComponent"
								ref=
								"myComponent"
								/>
								</bean>

There’s a lot of work happening behind the scenes, courtesy of the Spring AOP framework, although you aren’t forced to work with AOP concepts to enjoy the results. The myComponentbean definition creates a proxy for the EJB, which implements the business method interface. The EJB local home is cached on startup, so there’s only a single JNDI lookup. Each time the EJB is invoked, the proxy invokes the classnamemethod on the local EJB and invokes the corresponding business method on the EJB.

The myControllerbean definition sets the myComponentproperty of the controller class to the EJB proxy.

Alternatively (and preferably in case of many such proxy definitions), consider using the <jee:local-slsb>configuration element in Spring’s "jee" namespace:

								<jee:local-slsb
								id=
								"myComponent"
								jndi-name=
								"ejb/myBean"
								business-interface=
								"com.mycom.MyComponent"
								/>
								<bean
								id=
								"myController"
								class=
								"com.mycom.myController"
								>
								<property
								name=
								"myComponent"
								ref=
								"myComponent"
								/>
								</bean>

This EJB access mechanism delivers huge simplification of application code: the web tier code (or other EJB client code) has no dependence on the use of EJB. If we want to replace this EJB reference with a POJO or a mock object or other test stub, we could simply change the myComponentbean definition without changing a line of Java code. Additionally, we haven’t had to write a single line of JNDI lookup or other EJB plumbing code as part of our application.

Benchmarks and experience in real applications indicate that the performance overhead of this approach (which involves reflective invocation of the target EJB) is minimal, and is typically undetectable in typical use. Remember that we don’t want to make fine-grained calls to EJBs anyway, as there’s a cost associated with the EJB infrastructure in the application server.

There is one caveat with regards to the JNDI lookup. In a bean container, this class is normally best used as a singleton (there simply is no reason to make it a prototype). However, if that bean container pre-instantiates singletons (as do the various XML ApplicationContextvariants) you may have a problem if the bean container is loaded before the EJB container loads the target EJB. That is because the JNDI lookup will be performed in the init()method of this class and then cached, but the EJB will not have been bound at the target location yet. The solution is to not pre-instantiate this factory object, but allow it to be created on first use. In the XML containers, this is controlled via the lazy-initattribute.

Although this will not be of interest to the majority of Spring users, those doing programmatic AOP work with EJBs may want to look at LocalSlsbInvokerInterceptor.

29.2.3 Accessing remote SLSBs

Accessing remote EJBs is essentially identical to accessing local EJBs, except that the SimpleRemoteStatelessSessionProxyFactoryBeanor <jee:remote-slsb>configuration element is used. Of course, with or without Spring, remote invocation semantics apply; a call to a method on an object in another VM in another computer does sometimes have to be treated differently in terms of usage scenarios and failure handling.

Spring’s EJB client support adds one more advantage over the non-Spring approach. Normally it is problematic for EJB client code to be easily switched back and forth between calling EJBs locally or remotely. This is because the remote interface methods must declare that they throw RemoteException, and client code must deal with this, while the local interface methods don’t. Client code written for local EJBs which needs to be moved to remote EJBs typically has to be modified to add handling for the remote exceptions, and client code written for remote EJBs which needs to be moved to local EJBs, can either stay the same but do a lot of unnecessary handling of remote exceptions, or needs to be modified to remove that code. With the Spring remote EJB proxy, you can instead not declare any thrown RemoteExceptionin your Business Method Interface and implementing EJB code, have a remote interface which is identical except that it does throw RemoteException, and rely on the proxy to dynamically treat the two interfaces as if they were the same. That is, client code does not have to deal with the checked RemoteExceptionclass. Any actual RemoteExceptionthat is thrown during the EJB invocation will be re-thrown as the non-checked RemoteAccessExceptionclass, which is a subclass of RuntimeException. The target service can then be switched at will between a local EJB or remote EJB (or even plain Java object) implementation, without the client code knowing or caring. Of course, this is optional; there is nothing stopping you from declaring RemoteExceptionsin your business interface.

29.2.4 Accessing EJB 2.x SLSBs versus EJB 3 SLSBs

Accessing EJB 2.x Session Beans and EJB 3 Session Beans via Spring is largely transparent. Spring’s EJB accessors, including the <jee:local-slsb>and <jee:remote-slsb>facilities, transparently adapt to the actual component at runtime. They handle a home interface if found (EJB 2.x style), or perform straight component invocations if no home interface is available (EJB 3 style).

Note: For EJB 3 Session Beans, you could effectively use a JndiObjectFactoryBean/ <jee:jndi-lookup>as well, since fully usable component references are exposed for plain JNDI lookups there. Defining explicit <jee:local-slsb>/ <jee:remote-slsb>lookups simply provides consistent and more explicit EJB access configuration.

29.3 Using Spring’s EJB implementation support classes

29.3.1 EJB 3 injection interceptor

For EJB 3 Session Beans and Message-Driven Beans, Spring provides a convenient interceptor that resolves Spring’s @Autowiredannotation in the EJB component class: org.springframework.ejb.interceptor.SpringBeanAutowiringInterceptor. This interceptor can be applied through an @Interceptorsannotation in the EJB component class, or through an interceptor-bindingXML element in the EJB deployment descriptor.

								
									@Stateless
								
									@Interceptors(SpringBeanAutowiringInterceptor.class)
								public
								classMyFacadeEJB
								implementsMyFacadeLocal {
								// automatically injected with a matching Spring bean
								
									@Autowired
								privateMyComponent myComp;
								// for business method, delegate to POJO service impl.
								publicString myFacadeMethod(...) {
								returnmyComp.myMethod(...); } ... }

SpringBeanAutowiringInterceptorby default obtains target beans from a ContextSingletonBeanFactoryLocator, with the context defined in a bean definition file named beanRefContext.xml. By default, a single context definition is expected, which is obtained by type rather than by name. However, if you need to choose between multiple context definitions, a specific locator key is required. The locator key (i.e. the name of the context definition in beanRefContext.xml) can be explicitly specified either through overriding the getBeanFactoryLocatorKeymethod in a custom SpringBeanAutowiringInterceptorsubclass.

Alternatively, consider overriding SpringBeanAutowiringInterceptor’s `getBeanFactorymethod, e.g. obtaining a shared ApplicationContextfrom a custom holder class.

30. JMS (Java Message Service)

30.1 Introduction

Spring provides a JMS integration framework that simplifies the use of the JMS API much like Spring’s integration does for the JDBC API.

JMS can be roughly divided into two areas of functionality, namely the production and consumption of messages. The JmsTemplateclass is used for message production and synchronous message reception. For asynchronous reception similar to Java EE’s message-driven bean style, Spring provides a number of message listener containers that are used to create Message-Driven POJOs (MDPs). Spring also provides a declarative way of creating message listeners.

The package org.springframework.jms.coreprovides the core functionality for using JMS. It contains JMS template classes that simplify the use of the JMS by handling the creation and release of resources, much like the JdbcTemplatedoes for JDBC. The design principle common to Spring template classes is to provide helper methods to perform common operations and for more sophisticated usage, delegate the essence of the processing task to user implemented callback interfaces. The JMS template follows the same design. The classes offer various convenience methods for the sending of messages, consuming a message synchronously, and exposing the JMS session and message producer to the user.

The package org.springframework.jms.supportprovides JMSExceptiontranslation functionality. The translation converts the checked JMSExceptionhierarchy to a mirrored hierarchy of unchecked exceptions. If there are any provider specific subclasses of the checked javax.jms.JMSException, this exception is wrapped in the unchecked UncategorizedJmsException.

The package org.springframework.jms.support.converterprovides a MessageConverterabstraction to convert between Java objects and JMS messages.

The package org.springframework.jms.support.destinationprovides various strategies for managing JMS destinations, such as providing a service locator for destinations stored in JNDI.

The package org.springframework.jms.annotationprovides the necessary infrastructure to support annotation-driven listener endpoints using @JmsListener.

The package org.springframework.jms.configprovides the parser implementation for the jmsnamespace as well the java config support to configure listener containers and create listener endpoints.

Finally, the package org.springframework.jms.connectionprovides an implementation of the ConnectionFactorysuitable for use in standalone applications. It also contains an implementation of Spring’s PlatformTransactionManagerfor JMS (the cunningly named JmsTransactionManager). This allows for seamless integration of JMS as a transactional resource into Spring’s transaction management mechanisms.

30.2 Using Spring JMS

30.2.1 JmsTemplate

The JmsTemplateclass is the central class in the JMS core package. It simplifies the use of JMS since it handles the creation and release of resources when sending or synchronously receiving messages.

Code that uses the JmsTemplateonly needs to implement callback interfaces giving them a clearly defined high level contract. The MessageCreatorcallback interface creates a message given a Sessionprovided by the calling code in JmsTemplate. In order to allow for more complex usage of the JMS API, the callback SessionCallbackprovides the user with the JMS session and the callback ProducerCallbackexposes a Sessionand MessageProducerpair.

The JMS API exposes two types of send methods, one that takes delivery mode, priority, and time-to-live as Quality of Service (QOS) parameters and one that takes no QOS parameters which uses default values. Since there are many send methods in JmsTemplate, the setting of the QOS parameters have been exposed as bean properties to avoid duplication in the number of send methods. Similarly, the timeout value for synchronous receive calls is set using the property setReceiveTimeout.

Some JMS providers allow the setting of default QOS values administratively through the configuration of the ConnectionFactory. This has the effect that a call to MessageProducer’s send method `send(Destination destination, Message message)will use different QOS default values than those specified in the JMS specification. In order to provide consistent management of QOS values, the JmsTemplatemust therefore be specifically enabled to use its own QOS values by setting the boolean property isExplicitQosEnabledto true.

For convenience, JmsTemplatealso exposes a basic request-reply operation that allows to send a message and wait for a reply on a temporary queue that is created as part of the operation.

[Note] Note

Instances of the JmsTemplateclass are thread-safe once configured. This is important because it means that you can configure a single instance of a JmsTemplateand then safely inject this sharedreference into multiple collaborators. To be clear, the JmsTemplateis stateful, in that it maintains a reference to a ConnectionFactory, but this state is notconversational state.

As of Spring Framework 4.1, JmsMessagingTemplateis built on top of JmsTemplateand provides an integration with the messaging abstraction, i.e. org.springframework.messaging.Message. This allows you to create the message to send in generic manner.

30.2.2 Connections

The JmsTemplaterequires a reference to a ConnectionFactory. The ConnectionFactoryis part of the JMS specification and serves as the entry point for working with JMS. It is used by the client application as a factory to create connections with the JMS provider and encapsulates various configuration parameters, many of which are vendor specific such as SSL configuration options.

When using JMS inside an EJB, the vendor provides implementations of the JMS interfaces so that they can participate in declarative transaction management and perform pooling of connections and sessions. In order to use this implementation, Java EE containers typically require that you declare a JMS connection factory as a resource-refinside the EJB or servlet deployment descriptors. To ensure the use of these features with the JmsTemplateinside an EJB, the client application should ensure that it references the managed implementation of the ConnectionFactory.

Caching Messaging Resources

The standard API involves creating many intermediate objects. To send a message the following 'API' walk is performed

ConnectionFactory->Connection->Session->MessageProducer->send

Between the ConnectionFactory and the Send operation there are three intermediate objects that are created and destroyed. To optimise the resource usage and increase performance two implementations of ConnectionFactoryare provided.

SingleConnectionFactory

Spring provides an implementation of the ConnectionFactoryinterface, SingleConnectionFactory, that will return the same Connectionon all createConnection()calls and ignore calls to close(). This is useful for testing and standalone environments so that the same connection can be used for multiple JmsTemplatecalls that may span any number of transactions. SingleConnectionFactorytakes a reference to a standard ConnectionFactorythat would typically come from JNDI.

CachingConnectionFactory

The CachingConnectionFactoryextends the functionality of SingleConnectionFactoryand adds the caching of Sessions, MessageProducers, and MessageConsumers. The initial cache size is set to 1, use the property sessionCacheSizeto increase the number of cached sessions. Note that the number of actual cached sessions will be more than that number as sessions are cached based on their acknowledgment mode, so there can be up to 4 cached session instances when sessionCacheSizeis set to one, one for each acknowledgment mode. MessageProducers and MessageConsumers are cached within their owning session and also take into account the unique properties of the producers and consumers when caching. MessageProducers are cached based on their destination. MessageConsumers are cached based on a key composed of the destination, selector, noLocal delivery flag, and the durable subscription name (if creating durable consumers).

30.2.3 Destination Management

Destinations, like ConnectionFactories, are JMS administered objects that can be stored and retrieved in JNDI. When configuring a Spring application context you can use the JNDI factory class JndiObjectFactoryBean/ <jee:jndi-lookup>to perform dependency injection on your object’s references to JMS destinations. However, often this strategy is cumbersome if there are a large number of destinations in the application or if there are advanced destination management features unique to the JMS provider. Examples of such advanced destination management would be the creation of dynamic destinations or support for a hierarchical namespace of destinations. The JmsTemplatedelegates the resolution of a destination name to a JMS destination object to an implementation of the interface DestinationResolver. DynamicDestinationResolveris the default implementation used by JmsTemplateand accommodates resolving dynamic destinations. A JndiDestinationResolveris also provided that acts as a service locator for destinations contained in JNDI and optionally falls back to the behavior contained in DynamicDestinationResolver.

Quite often the destinations used in a JMS application are only known at runtime and therefore cannot be administratively created when the application is deployed. This is often because there is shared application logic between interacting system components that create destinations at runtime according to a well-known naming convention. Even though the creation of dynamic destinations is not part of the JMS specification, most vendors have provided this functionality. Dynamic destinations are created with a name defined by the user which differentiates them from temporary destinations and are often not registered in JNDI. The API used to create dynamic destinations varies from provider to provider since the properties associated with the destination are vendor specific. However, a simple implementation choice that is sometimes made by vendors is to disregard the warnings in the JMS specification and to use the TopicSessionmethod createTopic(String topicName)or the QueueSessionmethod createQueue(String queueName)to create a new destination with default destination properties. Depending on the vendor implementation, DynamicDestinationResolvermay then also create a physical destination instead of only resolving one.

The boolean property pubSubDomainis used to configure the JmsTemplatewith knowledge of what JMS domain is being used. By default the value of this property is false, indicating that the point-to-point domain, Queues, will be used. This property used by JmsTemplatedetermines the behavior of dynamic destination resolution via implementations of the DestinationResolverinterface.

You can also configure the JmsTemplatewith a default destination via the property defaultDestination. The default destination will be used with send and receive operations that do not refer to a specific destination.

30.2.4 Message Listener Containers

One of the most common uses of JMS messages in the EJB world is to drive message-driven beans (MDBs). Spring offers a solution to create message-driven POJOs (MDPs) in a way that does not tie a user to an EJB container. (See Section 30.4.2, “Asynchronous Reception - Message-Driven POJOs”for detailed coverage of Spring’s MDP support.) As from Spring Framework 4.1, endpoint methods can be simply annotated using @JmsListenersee Section 30.6, “Annotation-driven listener endpoints”for more details.

A message listener container is used to receive messages from a JMS message queue and drive the MessageListenerthat is injected into it. The listener container is responsible for all threading of message reception and dispatches into the listener for processing. A message listener container is the intermediary between an MDP and a messaging provider, and takes care of registering to receive messages, participating in transactions, resource acquisition and release, exception conversion and suchlike. This allows you as an application developer to write the (possibly complex) business logic associated with receiving a message (and possibly responding to it), and delegates boilerplate JMS infrastructure concerns to the framework.

There are two standard JMS message listener containers packaged with Spring, each with its specialised feature set.

SimpleMessageListenerContainer

This message listener container is the simpler of the two standard flavors. It creates a fixed number of JMS sessions and consumers at startup, registers the listener using the standard JMS MessageConsumer.setMessageListener()method, and leaves it up the JMS provider to perform listener callbacks. This variant does not allow for dynamic adaption to runtime demands or for participation in externally managed transactions. Compatibility-wise, it stays very close to the spirit of the standalone JMS specification - but is generally not compatible with Java EE’s JMS restrictions.

[Note] Note

While SimpleMessageListenerContainerdoes not allow for the participation in externally managed transactions, it does support native JMS transactions: simply switch the 'sessionTransacted' flag to 'true' or, in the namespace, set the 'acknowledge' attribute to 'transacted': Exceptions thrown from your listener will lead to a rollback then, with the message getting redelivered. Alternatively, consider using 'CLIENT_ACKNOWLEDGE' mode which provides redelivery in case of an exception as well but does not use transacted Sessions and therefore does not include any other Session operations (such as sending response messages) in the transaction protocol.

DefaultMessageListenerContainer

This message listener container is the one used in most cases. In contrast to SimpleMessageListenerContainer, this container variant allows for dynamic adaptation to runtime demands and is able to participate in externally managed transactions. Each received message is registered with an XA transaction when configured with a JtaTransactionManager; so processing may take advantage of XA transaction semantics. This listener container strikes a good balance between low requirements on the JMS provider, advanced functionality such as the participation in externally managed transactions, and compatibility with Java EE environments.

The cache level of the container can be customized. Note that when no caching is enabled, a new connection and a new session is created for each message reception. Combining this with a non durable subscription with high loads may lead to message lost. Make sure to use a proper cache level in such case.

This container also has recoverable capabilities when the broker goes down. By default, a simple BackOffimplementation retries every 5 seconds. It is possible to specify a custom BackOffimplementation for more fine-grained recovery options, see ExponentialBackOfffor an example.

[Note] Note

Like its sibling SimpleMessageListenerContainer, DefaultMessageListenerContainersupports native JMS transactions and also allows for customizing the acknowledgment mode. This is strongly recommended over externally managed transactions if feasible for your scenario: that is, if you can live with occasional duplicate messages in case of the JVM dying. Custom duplicate message detection steps in your business logic may cover such situations, e.g. in the form of a business entity existence check or a protocol table check. Any such arrangements will be significantly more efficient than the alternative: wrapping your entire processing with an XA transaction (through configuring your DefaultMessageListenerContainerwith an JtaTransactionManager), covering the reception of the JMS message as well as the execution of the business logic in your message listener (including database operations etc).

30.2.5 Transaction management

Spring provides a JmsTransactionManagerthat manages transactions for a single JMS ConnectionFactory. This allows JMS applications to leverage the managed transaction features of Spring as described in Chapter 17, Transaction Management . The JmsTransactionManagerperforms local resource transactions, binding a JMS Connection/Session pair from the specified ConnectionFactoryto the thread. JmsTemplateautomatically detects such transactional resources and operates on them accordingly.

In a Java EE environment, the ConnectionFactorywill pool Connections and Sessions, so those resources are efficiently reused across transactions. In a standalone environment, using Spring’s SingleConnectionFactorywill result in a shared JMS Connection, with each transaction having its own independent Session. Alternatively, consider the use of a provider-specific pooling adapter such as ActiveMQ’s PooledConnectionFactoryclass.

JmsTemplatecan also be used with the JtaTransactionManagerand an XA-capable JMS ConnectionFactoryfor performing distributed transactions. Note that this requires the use of a JTA transaction manager as well as a properly XA-configured ConnectionFactory! (Check your Java EE server’s / JMS provider’s documentation.)

Reusing code across a managed and unmanaged transactional environment can be confusing when using the JMS API to create a Sessionfrom a Connection. This is because the JMS API has only one factory method to create a Sessionand it requires values for the transaction and acknowledgment modes. In a managed environment, setting these values is the responsibility of the environment’s transactional infrastructure, so these values are ignored by the vendor’s wrapper to the JMS Connection. When using the JmsTemplatein an unmanaged environment you can specify these values through the use of the properties sessionTransactedand sessionAcknowledgeMode. When using a PlatformTransactionManagerwith JmsTemplate, the template will always be given a transactional JMS Session.

30.3 Sending a Message

The JmsTemplatecontains many convenience methods to send a message. There are send methods that specify the destination using a javax.jms.Destinationobject and those that specify the destination using a string for use in a JNDI lookup. The send method that takes no destination argument uses the default destination.

							importjavax.jms.ConnectionFactory;
							importjavax.jms.JMSException;
							importjavax.jms.Message;
							importjavax.jms.Queue;
							importjavax.jms.Session;
							importorg.springframework.jms.core.MessageCreator;
							importorg.springframework.jms.core.JmsTemplate;
							public
							classJmsQueueSender {
							privateJmsTemplate jmsTemplate;
							privateQueue queue;
							public
							voidsetConnectionFactory(ConnectionFactory cf) {
							this.jmsTemplate =
							newJmsTemplate(cf); }
							public
							voidsetQueue(Queue queue) {
							this.queue = queue; }
							public
							voidsimpleSend() {
							this.jmsTemplate.send(
							this.queue,
							newMessageCreator() {
							publicMessage createMessage(Session session)
							throwsJMSException {
							returnsession.createTextMessage(
							"hello queue world"); } }); } }

This example uses the MessageCreatorcallback to create a text message from the supplied Sessionobject. The JmsTemplateis constructed by passing a reference to a ConnectionFactory. As an alternative, a zero argument constructor and connectionFactoryis provided and can be used for constructing the instance in JavaBean style (using a BeanFactory or plain Java code). Alternatively, consider deriving from Spring’s JmsGatewaySupportconvenience base class, which provides pre-built bean properties for JMS configuration.

The method send(String destinationName, MessageCreator creator)lets you send a message using the string name of the destination. If these names are registered in JNDI, you should set the destinationResolverproperty of the template to an instance of JndiDestinationResolver.

If you created the JmsTemplateand specified a default destination, the send(MessageCreator c)sends a message to that destination.

30.3.1 Using Message Converters

In order to facilitate the sending of domain model objects, the JmsTemplatehas various send methods that take a Java object as an argument for a message’s data content. The overloaded methods convertAndSend()and receiveAndConvert()in JmsTemplatedelegate the conversion process to an instance of the MessageConverterinterface. This interface defines a simple contract to convert between Java objects and JMS messages. The default implementation SimpleMessageConvertersupports conversion between Stringand TextMessage, byte[]and BytesMesssage, and java.util.Mapand MapMessage. By using the converter, you and your application code can focus on the business object that is being sent or received via JMS and not be concerned with the details of how it is represented as a JMS message.

The sandbox currently includes a MapMessageConverterwhich uses reflection to convert between a JavaBean and a MapMessage. Other popular implementation choices you might implement yourself are Converters that use an existing XML marshalling package, such as JAXB, Castor, XMLBeans, or XStream, to create a TextMessagerepresenting the object.

To accommodate the setting of a message’s properties, headers, and body that can not be generically encapsulated inside a converter class, the MessagePostProcessorinterface gives you access to the message after it has been converted, but before it is sent. The example below demonstrates how to modify a message header and a property after a java.util.Mapis converted to a message.

								public
								voidsendWithConversion() { Map map =
								newHashMap(); map.put(
								"Name",
								"Mark"); map.put(
								"Age",
								newInteger(
								47)); jmsTemplate.convertAndSend(
								"testQueue", map,
								newMessagePostProcessor() {
								publicMessage postProcessMessage(Message message)
								throwsJMSException { message.setIntProperty(
								"AccountID",
								1234); message.setJMSCorrelationID(
								"123-00001");
								returnmessage; } }); }

This results in a message of the form:

MapMessage={ Header={ ... standard headers ... CorrelationID={123-00001} } Properties={ AccountID={Integer:1234} } Fields={ Name={String:Mark} Age={Integer:47} } }

30.3.2 SessionCallback and ProducerCallback

While the send operations cover many common usage scenarios, there are cases when you want to perform multiple operations on a JMS Sessionor MessageProducer. The SessionCallbackand ProducerCallbackexpose the JMS Sessionand Session/ MessageProducerpair respectively. The execute()methods on JmsTemplateexecute these callback methods.

30.4 Receiving a message

30.4.1 Synchronous Reception

While JMS is typically associated with asynchronous processing, it is possible to consume messages synchronously. The overloaded receive(..)methods provide this functionality. During a synchronous receive, the calling thread blocks until a message becomes available. This can be a dangerous operation since the calling thread can potentially be blocked indefinitely. The property receiveTimeoutspecifies how long the receiver should wait before giving up waiting for a message.

30.4.2 Asynchronous Reception - Message-Driven POJOs

[Note] Note

Spring also supports annotated-listener endpoints through the use of the @JmsListenerannotation and provides an open infrastructure to register endpoints programmatically. This is by far the most convenient way to setup an asynchronous receiver, see Section 30.6.1, “Enable listener endpoint annotations”for more details.

In a fashion similar to a Message-Driven Bean (MDB) in the EJB world, the Message-Driven POJO (MDP) acts as a receiver for JMS messages. The one restriction (but see also below for the discussion of the MessageListenerAdapterclass) on an MDP is that it must implement the javax.jms.MessageListenerinterface. Please also be aware that in the case where your POJO will be receiving messages on multiple threads, it is important to ensure that your implementation is thread-safe.

Below is a simple implementation of an MDP:

								importjavax.jms.JMSException;
								importjavax.jms.Message;
								importjavax.jms.MessageListener;
								importjavax.jms.TextMessage;
								public
								classExampleListener
								implementsMessageListener {
								public
								voidonMessage(Message message) {
								if(message
								instanceofTextMessage) {
								try{ System.out.println(((TextMessage) message).getText()); }
								catch(JMSException ex) {
								throw
								newRuntimeException(ex); } }
								else{
								throw
								newIllegalArgumentException(
								"Message must be of type TextMessage"); } } }

Once you’ve implemented your MessageListener, it’s time to create a message listener container.

Find below an example of how to define and configure one of the message listener containers that ships with Spring (in this case the DefaultMessageListenerContainer).

								<!-- this is the Message Driven POJO (MDP) -->
								<bean
								id=
								"messageListener"
								class=
								"jmsexample.ExampleListener"
								/>
								<!-- and this is the message listener container -->
								<bean
								id=
								"jmsContainer"
								class=
								"org.springframework.jms.listener.DefaultMessageListenerContainer"
								>
								<property
								name=
								"connectionFactory"
								ref=
								"connectionFactory"
								/>
								<property
								name=
								"destination"
								ref=
								"destination"
								/>
								
									<property name="messageListener" ref="messageListener" />
								</bean>

Please refer to the Spring javadocs of the various message listener containers for a full description of the features supported by each implementation.

30.4.3 the SessionAwareMessageListener interface

The SessionAwareMessageListenerinterface is a Spring-specific interface that provides a similar contract to the JMS MessageListenerinterface, but also provides the message handling method with access to the JMS Sessionfrom which the Messagewas received.

								packageorg.springframework.jms.listener;
								public
								interfaceSessionAwareMessageListener {
								voidonMessage(Message message, Session session)
								throwsJMSException; }

You can choose to have your MDPs implement this interface (in preference to the standard JMS MessageListenerinterface) if you want your MDPs to be able to respond to any received messages (using the Sessionsupplied in the onMessage(Message, Session)method). All of the message listener container implementations that ship with Spring have support for MDPs that implement either the MessageListeneror SessionAwareMessageListenerinterface. Classes that implement the SessionAwareMessageListenercome with the caveat that they are then tied to Spring through the interface. The choice of whether or not to use it is left entirely up to you as an application developer or architect.

Please note that the 'onMessage(..)'method of the SessionAwareMessageListenerinterface throws JMSException. In contrast to the standard JMS MessageListenerinterface, when using the SessionAwareMessageListenerinterface, it is the responsibility of the client code to handle any exceptions thrown.

30.4.4 the MessageListenerAdapter

The MessageListenerAdapterclass is the final component in Spring’s asynchronous messaging support: in a nutshell, it allows you to expose almost anyclass as a MDP (there are of course some constraints).

Consider the following interface definition. Notice that although the interface extends neither the MessageListenernor SessionAwareMessageListenerinterfaces, it can still be used as a MDP via the use of the MessageListenerAdapterclass. Notice also how the various message handling methods are strongly typed according to the contentsof the various Messagetypes that they can receive and handle.

								public
								interfaceMessageDelegate {
								voidhandleMessage(String message);
								voidhandleMessage(Map message);
								voidhandleMessage(
								byte[] message);
								voidhandleMessage(Serializable message); }
								public
								classDefaultMessageDelegate
								implementsMessageDelegate {
								// implementation elided for clarity...}

In particular, note how the above implementation of the MessageDelegateinterface (the above DefaultMessageDelegateclass) has noJMS dependencies at all. It truly is a POJO that we will make into an MDP via the following configuration.

								<!-- this is the Message Driven POJO (MDP) -->
								
									<bean id="messageListener" class="org.springframework.jms.listener.adapter.MessageListenerAdapter"> <constructor-arg> <bean class="jmsexample.DefaultMessageDelegate"/> </constructor-arg> </bean>
								<!-- and this is the message listener container... -->
								<bean
								id=
								"jmsContainer"
								class=
								"org.springframework.jms.listener.DefaultMessageListenerContainer"
								>
								<property
								name=
								"connectionFactory"
								ref=
								"connectionFactory"
								/>
								<property
								name=
								"destination"
								ref=
								"destination"
								/>
								
									<property name="messageListener" ref="messageListener" />
								</bean>

Below is an example of another MDP that can only handle the receiving of JMS TextMessagemessages. Notice how the message handling method is actually called 'receive'(the name of the message handling method in a MessageListenerAdapterdefaults to 'handleMessage'), but it is configurable (as you will see below). Notice also how the 'receive(..)'method is strongly typed to receive and respond only to JMS TextMessagemessages.

								public
								interfaceTextMessageDelegate {
								voidreceive(TextMessage message); }
								public
								classDefaultTextMessageDelegate
								implementsTextMessageDelegate {
								// implementation elided for clarity...}

The configuration of the attendant MessageListenerAdapterwould look like this:

								<bean
								id=
								"messageListener"
								class=
								"org.springframework.jms.listener.adapter.MessageListenerAdapter"
								>
								<constructor-arg>
								<bean
								class=
								"jmsexample.DefaultTextMessageDelegate"
								/>
								</constructor-arg>
								<property
								name=
								"defaultListenerMethod"
								value=
								"receive"
								/>
								<!-- we don't want automatic message context extraction -->
								<property
								name=
								"messageConverter"
								>
								<null/>
								</property>
								</bean>

Please note that if the above 'messageListener'receives a JMS Messageof a type other than TextMessage, an IllegalStateExceptionwill be thrown (and subsequently swallowed). Another of the capabilities of the MessageListenerAdapterclass is the ability to automatically send back a response Messageif a handler method returns a non-void value. Consider the interface and class:

								public
								interfaceResponsiveTextMessageDelegate {
								// notice the return type...String receive(TextMessage message); }
								public
								classDefaultResponsiveTextMessageDelegate
								implementsResponsiveTextMessageDelegate {
								// implementation elided for clarity...}

If the above DefaultResponsiveTextMessageDelegateis used in conjunction with a MessageListenerAdapterthen any non-null value that is returned from the execution of the 'receive(..)'method will (in the default configuration) be converted into a TextMessage. The resulting TextMessagewill then be sent to the Destination(if one exists) defined in the JMS Reply-To property of the original Message, or the default Destinationset on the MessageListenerAdapter(if one has been configured); if no Destinationis found then an InvalidDestinationExceptionwill be thrown (and please note that this exception will notbe swallowed and willpropagate up the call stack).

30.4.5 Processing messages within transactions

Invoking a message listener within a transaction only requires reconfiguration of the listener container.

Local resource transactions can simply be activated through the sessionTransactedflag on the listener container definition. Each message listener invocation will then operate within an active JMS transaction, with message reception rolled back in case of listener execution failure. Sending a response message (via SessionAwareMessageListener) will be part of the same local transaction, but any other resource operations (such as database access) will operate independently. This usually requires duplicate message detection in the listener implementation, covering the case where database processing has committed but message processing failed to commit.

								<bean
								id=
								"jmsContainer"
								class=
								"org.springframework.jms.listener.DefaultMessageListenerContainer"
								>
								<property
								name=
								"connectionFactory"
								ref=
								"connectionFactory"
								/>
								<property
								name=
								"destination"
								ref=
								"destination"
								/>
								<property
								name=
								"messageListener"
								ref=
								"messageListener"
								/>
								
									<property name="sessionTransacted" value="true"/>
								</bean>

For participating in an externally managed transaction, you will need to configure a transaction manager and use a listener container which supports externally managed transactions: typically DefaultMessageListenerContainer.

To configure a message listener container for XA transaction participation, you’ll want to configure a JtaTransactionManager(which, by default, delegates to the Java EE server’s transaction subsystem). Note that the underlying JMS ConnectionFactory needs to be XA-capable and properly registered with your JTA transaction coordinator! (Check your Java EE server’s configuration of JNDI resources.) This allows message reception as well as e.g. database access to be part of the same transaction (with unified commit semantics, at the expense of XA transaction log overhead).

								<bean
								id=
								"transactionManager"
								class=
								"org.springframework.transaction.jta.JtaTransactionManager"
								/>

Then you just need to add it to our earlier container configuration. The container will take care of the rest.

								<bean
								id=
								"jmsContainer"
								class=
								"org.springframework.jms.listener.DefaultMessageListenerContainer"
								>
								<property
								name=
								"connectionFactory"
								ref=
								"connectionFactory"
								/>
								<property
								name=
								"destination"
								ref=
								"destination"
								/>
								<property
								name=
								"messageListener"
								ref=
								"messageListener"
								/>
								
									<property name="transactionManager" ref="transactionManager"/>
								</bean>

30.5 Support for JCA Message Endpoints

Beginning with version 2.5, Spring also provides support for a JCA-based MessageListenercontainer. The JmsMessageEndpointManagerwill attempt to automatically determine the ActivationSpecclass name from the provider’s ResourceAdapterclass name. Therefore, it is typically possible to just provide Spring’s generic JmsActivationSpecConfigas shown in the following example.

							<bean
							class=
							"org.springframework.jms.listener.endpoint.JmsMessageEndpointManager"
							>
							<property
							name=
							"resourceAdapter"
							ref=
							"resourceAdapter"
							/>
							<property
							name=
							"activationSpecConfig"
							>
							<bean
							class=
							"org.springframework.jms.listener.endpoint.JmsActivationSpecConfig"
							>
							<property
							name=
							"destinationName"
							value=
							"myQueue"
							/>
							</bean>
							</property>
							<property
							name=
							"messageListener"
							ref=
							"myMessageListener"
							/>
							</bean>

Alternatively, you may set up a JmsMessageEndpointManagerwith a given ActivationSpecobject. The ActivationSpecobject may also come from a JNDI lookup (using <jee:jndi-lookup>).

							<bean
							class=
							"org.springframework.jms.listener.endpoint.JmsMessageEndpointManager"
							>
							<property
							name=
							"resourceAdapter"
							ref=
							"resourceAdapter"
							/>
							<property
							name=
							"activationSpec"
							>
							<bean
							class=
							"org.apache.activemq.ra.ActiveMQActivationSpec"
							>
							<property
							name=
							"destination"
							value=
							"myQueue"
							/>
							<property
							name=
							"destinationType"
							value=
							"javax.jms.Queue"
							/>
							</bean>
							</property>
							<property
							name=
							"messageListener"
							ref=
							"myMessageListener"
							/>
							</bean>

Using Spring’s ResourceAdapterFactoryBean, the target ResourceAdaptermay be configured locally as depicted in the following example.

							<bean
							id=
							"resourceAdapter"
							class=
							"org.springframework.jca.support.ResourceAdapterFactoryBean"
							>
							<property
							name=
							"resourceAdapter"
							>
							<bean
							class=
							"org.apache.activemq.ra.ActiveMQResourceAdapter"
							>
							<property
							name=
							"serverUrl"
							value=
							"tcp://localhost:61616"
							/>
							</bean>
							</property>
							<property
							name=
							"workManager"
							>
							<bean
							class=
							"org.springframework.jca.work.SimpleTaskWorkManager"
							/>
							</property>
							</bean>

The specified WorkManagermay also point to an environment-specific thread pool - typically through SimpleTaskWorkManager’s"asyncTaskExecutor" property. Consider defining a shared thread pool for all your ResourceAdapterinstances if you happen to use multiple adapters.

In some environments (e.g. WebLogic 9 or above), the entire ResourceAdapterobject may be obtained from JNDI instead (using <jee:jndi-lookup>). The Spring-based message listeners can then interact with the server-hosted ResourceAdapter, also using the server’s built-in WorkManager.

Please consult the JavaDoc for JmsMessageEndpointManager, JmsActivationSpecConfig, and ResourceAdapterFactoryBeanfor more details.

Spring also provides a generic JCA message endpoint manager which is not tied to JMS: org.springframework.jca.endpoint.GenericMessageEndpointManager. This component allows for using any message listener type (e.g. a CCI MessageListener) and any provider-specific ActivationSpec object. Check out your JCA provider’s documentation to find out about the actual capabilities of your connector, and consult `GenericMessageEndpointManager’s JavaDoc for the Spring-specific configuration details.

[Note] Note

JCA-based message endpoint management is very analogous to EJB 2.1 Message-Driven Beans; it uses the same underlying resource provider contract. Like with EJB 2.1 MDBs, any message listener interface supported by your JCA provider can be used in the Spring context as well. Spring nevertheless provides explicit 'convenience' support for JMS, simply because JMS is the most common endpoint API used with the JCA endpoint management contract.

30.6 Annotation-driven listener endpoints

The easiest way to receive a message asynchronously is to use the annotated listener endpoint infrastructure. In a nutshell, it allows you to expose a method of a managed bean as a JMS listener endpoint.

							
								@Component
							public
							classMyService {
							
								@JmsListener(destination = "myDestination")
							public
							voidprocessOrder(String data) { ... } }

The idea of the example above is that whenever a message is available on the javax.jms.Destination"myDestination", the processOrdermethod is invoked accordingly (in this case, with the content of the JMS message similarly to what the MessageListenerAdapterprovides).

The annotated endpoint infrastructure creates a message listener container behind the scenes for each annotated method, using a JmsListenerContainerFactory. Such a container is not registered against the application context but can be easily located for management purposes using the JmsListenerEndpointRegistrybean.

[Tip] Tip

@JmsListeneris a repeatableannotation on Java 8, so it is possible to associate several JMS destinations to the same method by adding additional @JmsListenerdeclarations to it. On Java 6 and 7, you can use the @JmsListenersannotation.

30.6.1 Enable listener endpoint annotations

To enable support for @JmsListenerannotations add @EnableJmsto one of your @Configurationclasses.

								
									@Configuration
								
									@EnableJms
								public
								classAppConfig {
								
									@Bean
								publicDefaultJmsListenerContainerFactory jmsListenerContainerFactory() { DefaultJmsListenerContainerFactory factory =
								newDefaultJmsListenerContainerFactory(); factory.setConnectionFactory(connectionFactory()); factory.setDestinationResolver(destinationResolver()); factory.setConcurrency(
								"3-10");
								returnfactory; } }

By default, the infrastructure looks for a bean named jmsListenerContainerFactoryas the source for the factory to use to create message listener containers. In this case, and ignoring the JMS infrastructure setup, the processOrdermethod can be invoked with a core poll size of 3 threads and a maximum pool size of 10 threads.

It is possible to customize the listener container factory to use per annotation or an explicit default can be configured by implementing the JmsListenerConfigurerinterface. The default is only required if at least one endpoint is registered without a specific container factory. See the javadoc for full details and examples.

If you prefer XML configurationuse the <jms:annotation-driven>element.

								<jms:annotation-driven/>
								<bean
								id=
								"jmsListenerContainerFactory"
								class=
								"org.springframework.jms.config.DefaultJmsListenerContainerFactory"
								>
								<property
								name=
								"connectionFactory"
								ref=
								"connectionFactory"
								/>
								<property
								name=
								"destinationResolver"
								ref=
								"destinationResolver"
								/>
								<property
								name=
								"concurrency"
								value=
								"3-10"
								/>
								</bean>

30.6.2 Programmatic endpoints registration

JmsListenerEndpointprovides a model of an JMS endpoint and is responsible for configuring the container for that model. The infrastructure allows you to configure endpoints programmatically in addition to the ones that are detected by the JmsListenerannotation.

								
									@Configuration
								
									@EnableJms
								public
								classAppConfig
								implementsJmsListenerConfigurer {
								
									@Override
								public
								voidconfigureJmsListeners(JmsListenerEndpointRegistrar registrar) { SimpleJmsListenerEndpoint endpoint =
								newSimpleJmsListenerEndpoint(); endpoint.setId(
								"myJmsEndpoint"); endpoint.setDestination(
								"anotherQueue"); endpoint.setMessageListener(message -> {
								// processing}); registrar.registerEndpoint(endpoint); } }

In the example above, we used SimpleJmsListenerEndpointwhich provides the actual MessageListenerto invoke but you could just as well build your own endpoint variant describing a custom invocation mechanism.

It should be noted that you could just as well skip the use of @JmsListeneraltogether and only register your endpoints programmatically through JmsListenerConfigurer.

30.6.3 Annotated endpoint method signature

So far, we have been injecting a simple Stringin our endpoint but it can actually have a very flexible method signature. Let’s rewrite it to inject the Orderwith a custom header:

								
									@Component
								public
								classMyService {
								
									@JmsListener(destination = "myDestination")
								public
								voidprocessOrder(Order order,
								
									@Header("order_type")String orderType) { ... } }

These are the main elements you can inject in JMS listener endpoints:

  • The raw javax.jms.Messageor any of its subclasses (provided of course that it matches the incoming message type).
  • The javax.jms.Sessionfor optional access to the native JMS API e.g. for sending a custom reply.
  • The org.springframework.messaging.Messagerepresenting the incoming JMS message. Note that this message holds both the custom and the standard headers (as defined by JmsHeaders).
  • @Header-annotated method arguments to extract a specific header value, including standard JMS headers.
  • @Headers-annotated argument that must also be assignable to java.util.Mapfor getting access to all headers.
  • A non-annotated element that is not one of the supported types (i.e. Messageand Session) is considered to be the payload. You can make that explicit by annotating the parameter with @Payload. You can also turn on validation by adding an extra @Valid.

The ability to inject Spring’s Messageabstraction is particularly useful to benefit from all the information stored in the transport-specific message without relying on transport-specific API.

								
									@JmsListener(destination = "myDestination")
								public
								voidprocessOrder(Message<Order> order) { ... }

Handling of method arguments is provided by DefaultMessageHandlerMethodFactorywhich can be further customized to support additional method arguments. The conversion and validation support can be customized there as well.

For instance, if we want to make sure our Orderis valid before processing it, we can annotate the payload with @Validand configure the necessary validator as follows:

								
									@Configuration
								
									@EnableJms
								public
								classAppConfig
								implementsJmsListenerConfigurer {
								
									@Override
								public
								voidconfigureJmsListeners(JmsListenerEndpointRegistrar registrar) { registrar.setMessageHandlerMethodFactory(myJmsHandlerMethodFactory()); }
								
									@Bean
								publicDefaultMessageHandlerMethodFactory myHandlerMethodFactory() { DefaultMessageHandlerMethodFactory factory =
								newDefaultMessageHandlerMethodFactory(); factory.setValidator(myValidator());
								returnfactory; } }

30.6.4 Response management

The existing support in MessageListenerAdapteralready allows your method to have a non- voidreturn type. When that’s the case, the result of the invocation is encapsulated in a javax.jms.Messagesent either in the destination specified in the JMSReplyToheader of the original message or in the default destination configured on the listener. That default destination can now be set using the @SendToannotation of the messaging abstraction.

Assuming our processOrdermethod should now return an OrderStatus, it is possible to write it as follow to automatically send a response:

								
									@JmsListener(destination = "myDestination")
								
									@SendTo("status")
								publicOrderStatus processOrder(Order order) {
								// order processing
								returnstatus; }
[Tip] Tip

If you have several @JmsListener-annotated methods, you can also place the @SendToannotation at the class level to share a default reply destination.

If you need to set additional headers in a transport-independent manner, you could return a Messageinstead, something like:

								
									@JmsListener(destination = "myDestination")
								
									@SendTo("status")
								publicMessage<OrderStatus> processOrder(Order order) {
								// order processing
								returnMessageBuilder .withPayload(status) .setHeader(
								"code",
								1234) .build(); }

If you need to compute the response destination at runtime, you can encapsulate your response in a JmsResponseinstance that also provides the destination to use at runtime. The previous example can be rewritten as follows:

								
									@JmsListener(destination = "myDestination")
								publicJmsResponse<Message<OrderStatus>> processOrder(Order order) {
								// order processingMessage<OrderStatus> response = MessageBuilder .withPayload(status) .setHeader(
								"code",
								1234) .build();
								returnJmsResponse.forQueue(response,
								"status"); }

30.7 JMS namespace support

Spring provides an XML namespace for simplifying JMS configuration. To use the JMS namespace elements you will need to reference the JMS schema:

							<?xml version="1.0" encoding="UTF-8"?>
							<beans
							xmlns=
							"http://www.springframework.org/schema/beans"
							xmlns:xsi=
							"http://www.w3.org/2001/XMLSchema-instance"
							
								xmlns:jms="http://www.springframework.org/schema/jms"xsi:schemaLocation=" http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
							
								http://www.springframework.org/schema/jms http://www.springframework.org/schema/jms/spring-jms.xsd">
							<!-- bean definitions here -->
							</beans>

The namespace consists of three top-level elements: <annotation-driven/>, <listener-container/>and <jca-listener-container/>. <annotation-drivenenables the use of annotation-driven listener endpoints. <listener-container/>and <jca-listener-container/>defines shared listener container configuration and may contain <listener/>child elements. Here is an example of a basic configuration for two listeners.

							<jms:listener-container>
							<jms:listener
							destination=
							"queue.orders"
							ref=
							"orderService"
							method=
							"placeOrder"
							/>
							<jms:listener
							destination=
							"queue.confirmations"
							ref=
							"confirmationLogger"
							method=
							"log"
							/>
							</jms:listener-container>

The example above is equivalent to creating two distinct listener container bean definitions and two distinct MessageListenerAdapterbean definitions as demonstrated in Section 30.4.4, “the MessageListenerAdapter”. In addition to the attributes shown above, the listenerelement may contain several optional ones. The following table describes all available attributes:

Table 30.1. Attributes of the JMS <listener> element

Attribute Description

id

A bean name for the hosting listener container. If not specified, a bean name will be automatically generated.

destination (required)

The destination name for this listener, resolved through the DestinationResolverstrategy.

ref (required)

The bean name of the handler object.

method

The name of the handler method to invoke. If the refpoints to a MessageListeneror Spring SessionAwareMessageListener, this attribute may be omitted.

response-destination

The name of the default response destination to send response messages to. This will be applied in case of a request message that does not carry a "JMSReplyTo" field. The type of this destination will be determined by the listener-container’s "response-destination-type" attribute. Note: This only applies to a listener method with a return value, for which each result object will be converted into a response message.

subscription

The name of the durable subscription, if any.

selector

An optional message selector for this listener.

concurrency

The number of concurrent sessions/consumers to start for this listener. Can either be a simple number indicating the maximum number (e.g. "5") or a range indicating the lower as well as the upper limit (e.g. "3-5"). Note that a specified minimum is just a hint and might be ignored at runtime. Default is the value provided by the container

The <listener-container/>element also accepts several optional attributes. This allows for customization of the various strategies (for example, taskExecutorand destinationResolver) as well as basic JMS settings and resource references. Using these attributes, it is possible to define highly-customized listener containers while still benefiting from the convenience of the namespace.

Such settings can be automatically exposed as a JmsListenerContainerFactoryby specifying the id of the bean to expose through the factory-idattribute.

							<jms:listener-container
							connection-factory=
							"myConnectionFactory"
							task-executor=
							"myTaskExecutor"
							destination-resolver=
							"myDestinationResolver"
							transaction-manager=
							"myTransactionManager"
							concurrency=
							"10"
							>
							<jms:listener
							destination=
							"queue.orders"
							ref=
							"orderService"
							method=
							"placeOrder"
							/>
							<jms:listener
							destination=
							"queue.confirmations"
							ref=
							"confirmationLogger"
							method=
							"log"
							/>
							</jms:listener-container>

The following table describes all available attributes. Consult the class-level javadocs of the AbstractMessageListenerContainerand its concrete subclasses for more details on the individual properties. The javadocs also provide a discussion of transaction choices and message redelivery scenarios.

Table 30.2. Attributes of the JMS <listener-container> element

Attribute Description

container-type

The type of this listener container. Available options are: default, simple, default102, or simple102(the default value is 'default').

container-class

A custom listener container implementation class as fully qualified class name. Default is Spring’s standard DefaultMessageListenerContaineror SimpleMessageListenerContainer, according to the "container-type" attribute.

factory-id

Exposes the settings defined by this element as a JmsListenerContainerFactorywith the specified id so that they can be reused with other endpoints.

connection-factory

A reference to the JMS ConnectionFactorybean (the default bean name is 'connectionFactory').

task-executor

A reference to the Spring TaskExecutorfor the JMS listener invokers.

destination-resolver

A reference to the DestinationResolverstrategy for resolving JMS Destinations.

message-converter

A reference to the MessageConverterstrategy for converting JMS Messages to listener method arguments. Default is a SimpleMessageConverter.

error-handler

A reference to an ErrorHandlerstrategy for handling any uncaught Exceptions that may occur during the execution of the MessageListener.

destination-type

The JMS destination type for this listener: queue, topic, durableTopic, sharedTopicor sharedDurableTopic. This enables potentially the pubSubDomain, subscriptionDurableand subscriptionSharedproperties of the container. The default is queue(i.e. disabling those 3 properties).

response-destination-type

The JMS destination type for responses: "queue", "topic". Default is the value of the "destination-type" attribute.

client-id

The JMS client id for this listener container. Needs to be specified when using durable subscriptions.

cache

The cache level for JMS resources: none, connection, session, consumeror auto. By default ( auto), the cache level will effectively be "consumer", unless an external transaction manager has been specified - in which case the effective default will be none(assuming Java EE-style transaction management where the given ConnectionFactory is an XA-aware pool).

acknowledge

The native JMS acknowledge mode: auto, client, dups-okor transacted. A value of transactedactivates a locally transacted Session. As an alternative, specify the transaction-managerattribute described below. Default is auto.

transaction-manager

A reference to an external PlatformTransactionManager(typically an XA-based transaction coordinator, e.g. Spring’s JtaTransactionManager). If not specified, native acknowledging will be used (see "acknowledge" attribute).

concurrency

The number of concurrent sessions/consumers to start for each listener. Can either be a simple number indicating the maximum number (e.g. "5") or a range indicating the lower as well as the upper limit (e.g. "3-5"). Note that a specified minimum is just a hint and might be ignored at runtime. Default is 1; keep concurrency limited to 1 in case of a topic listener or if queue ordering is important; consider raising it for general queues.

prefetch

The maximum number of messages to load into a single session. Note that raising this number might lead to starvation of concurrent consumers!

receive-timeout

The timeout to use for receive calls (in milliseconds). The default is 1000ms (1 sec); -1indicates no timeout at all.

back-off

Specify the BackOffinstance to use to compute the interval between recovery attempts. If the BackOffExecutionimplementation returns BackOffExecution#STOP, the listener container will not further attempt to recover. The recovery-intervalvalue is ignored when this property is set. The default is a FixedBackOffwith an interval of 5000 ms, that is 5 seconds.

recovery-interval

Specify the interval between recovery attempts, in milliseconds. Convenience way to create a FixedBackOffwith the specified interval. For more recovery options, consider specifying a BackOff instance instead. The default is 5000 ms, that is 5 seconds.

phase

The lifecycle phase within which this container should start and stop. The lower the value the earlier this container will start and the later it will stop. The default is Integer.MAX_VALUEmeaning the container will start as late as possible and stop as soon as possible.

Configuring a JCA-based listener container with the "jms" schema support is very similar.

							<jms:jca-listener-container
							resource-adapter=
							"myResourceAdapter"
							destination-resolver=
							"myDestinationResolver"
							transaction-manager=
							"myTransactionManager"
							concurrency=
							"10"
							>
							<jms:listener
							destination=
							"queue.orders"
							ref=
							"myMessageListener"
							/>
							</jms:jca-listener-container>

The available configuration options for the JCA variant are described in the following table:

Table 30.3. Attributes of the JMS <jca-listener-container/> element

Attribute Description

factory-id

Exposes the settings defined by this element as a JmsListenerContainerFactorywith the specified id so that they can be reused with other endpoints.

resource-adapter

A reference to the JCA ResourceAdapterbean (the default bean name is 'resourceAdapter').

activation-spec-factory

A reference to the JmsActivationSpecFactory. The default is to autodetect the JMS provider and its ActivationSpecclass (see DefaultJmsActivationSpecFactory)

destination-resolver

A reference to the DestinationResolverstrategy for resolving JMS Destinations.

message-converter

A reference to the MessageConverterstrategy for converting JMS Messages to listener method arguments. Default is a SimpleMessageConverter.

destination-type

The JMS destination type for this listener: queue, topic, durableTopic, sharedTopicor sharedDurableTopic. This enables potentially the pubSubDomain, subscriptionDurableand subscriptionSharedproperties of the container. The default is queue(i.e. disabling those 3 properties).

response-destination-type

The JMS destination type for responses: "queue", "topic". Default is the value of the "destination-type" attribute.

client-id

The JMS client id for this listener container. Needs to be specified when using durable subscriptions.

acknowledge

The native JMS acknowledge mode: auto, client, dups-okor transacted. A value of transactedactivates a locally transacted Session. As an alternative, specify the transaction-managerattribute described below. Default is auto.

transaction-manager

A reference to a Spring JtaTransactionManageror a javax.transaction.TransactionManagerfor kicking off an XA transaction for each incoming message. If not specified, native acknowledging will be used (see the "acknowledge" attribute).

concurrency

The number of concurrent sessions/consumers to start for each listener. Can either be a simple number indicating the maximum number (e.g. "5") or a range indicating the lower as well as the upper limit (e.g. "3-5"). Note that a specified minimum is just a hint and will typically be ignored at runtime when using a JCA listener container. Default is 1.

prefetch

The maximum number of messages to load into a single session. Note that raising this number might lead to starvation of concurrent consumers!

31. JMX

31.1 Introduction

The JMX support in Spring provides you with the features to easily and transparently integrate your Spring application into a JMX infrastructure.

JMX?

This chapter is not an introduction to JMX…​ it doesn’t try to explain the motivations of why one might want to use JMX (or indeed what the letters JMX actually stand for). If you are new to JMX, check out Section 31.8, “Further Resources”at the end of this chapter.

Specifically, Spring’s JMX support provides four core features:

  • The automatic registration of anySpring bean as a JMX MBean
  • A flexible mechanism for controlling the management interface of your beans
  • The declarative exposure of MBeans over remote, JSR-160 connectors
  • The simple proxying of both local and remote MBean resources

These features are designed to work without coupling your application components to either Spring or JMX interfaces and classes. Indeed, for the most part your application classes need not be aware of either Spring or JMX in order to take advantage of the Spring JMX features.

31.2 Exporting your beans to JMX

The core class in Spring’s JMX framework is the MBeanExporter. This class is responsible for taking your Spring beans and registering them with a JMX MBeanServer. For example, consider the following class:

							packageorg.springframework.jmx;
							public
							classJmxTestBean
							implementsIJmxTestBean {
							privateString name;
							private
							intage;
							private
							booleanisSuperman;
							public
							intgetAge() {
							returnage; }
							public
							voidsetAge(
							intage) {
							this.age = age; }
							public
							voidsetName(String name) {
							this.name = name; }
							publicString getName() {
							returnname; }
							public
							intadd(
							intx,
							inty) {
							returnx + y; }
							public
							voiddontExposeMe() {
							throw
							newRuntimeException(); } }

To expose the properties and methods of this bean as attributes and operations of an MBean you simply configure an instance of the MBeanExporterclass in your configuration file and pass in the bean as shown below:

							<beans>
							<!-- this bean must not be lazily initialized if the exporting is to happen -->
							<bean
							id=
							"exporter"
							class=
							"org.springframework.jmx.export.MBeanExporter"
							lazy-init=
							"false"
							>
							<property
							name=
							"beans"
							>
							<map>
							<entry
							key=
							"bean:name=testBean1"
							value-ref=
							"testBean"
							/>
							</map>
							</property>
							</bean>
							<bean
							id=
							"testBean"
							class=
							"org.springframework.jmx.JmxTestBean"
							>
							<property
							name=
							"name"
							value=
							"TEST"
							/>
							<property
							name=
							"age"
							value=
							"100"
							/>
							</bean>
							</beans>

The pertinent bean definition from the above configuration snippet is the exporterbean. The beansproperty tells the MBeanExporterexactly which of your beans must be exported to the JMX MBeanServer. In the default configuration, the key of each entry in the beans Mapis used as the ObjectNamefor the bean referenced by the corresponding entry value. This behavior can be changed as described in Section 31.4, “Controlling the ObjectNames for your beans”.

With this configuration the testBeanbean is exposed as an MBean under the ObjectName bean:name=testBean1. By default, all publicproperties of the bean are exposed as attributes and all publicmethods (bar those inherited from the Objectclass) are exposed as operations.

[Note] Note

MBeanExporteris a Lifecyclebean (see the section called “Startup and shutdown callbacks”) and MBeans are exported as late as possible during the application lifecycle by default. It is possible to configure the phaseat which the export happens or disable automatic registration by setting the autoStartupflag.

31.2.1 Creating an MBeanServer

The above configuration assumes that the application is running in an environment that has one (and only one) MBeanServeralready running. In this case, Spring will attempt to locate the running MBeanServerand register your beans with that server (if any). This behavior is useful when your application is running inside a container such as Tomcat or IBM WebSphere that has its own MBeanServer.

However, this approach is of no use in a standalone environment, or when running inside a container that does not provide an MBeanServer. To address this you can create an MBeanServerinstance declaratively by adding an instance of the org.springframework.jmx.support.MBeanServerFactoryBeanclass to your configuration. You can also ensure that a specific MBeanServeris used by setting the value of the MBeanExporter’s `serverproperty to the MBeanServervalue returned by an MBeanServerFactoryBean; for example:

								<beans>
								<bean
								id=
								"mbeanServer"
								class=
								"org.springframework.jmx.support.MBeanServerFactoryBean"
								/>
								<!-- this bean needs to be eagerly pre-instantiated in order for the exporting to occur; this means that it must not be marked as lazily initialized -->
								<bean
								id=
								"exporter"
								class=
								"org.springframework.jmx.export.MBeanExporter"
								>
								<property
								name=
								"beans"
								>
								<map>
								<entry
								key=
								"bean:name=testBean1"
								value-ref=
								"testBean"
								/>
								</map>
								</property>
								<property
								name=
								"server"
								ref=
								"mbeanServer"
								/>
								</bean>
								<bean
								id=
								"testBean"
								class=
								"org.springframework.jmx.JmxTestBean"
								>
								<property
								name=
								"name"
								value=
								"TEST"
								/>
								<property
								name=
								"age"
								value=
								"100"
								/>
								</bean>
								</beans>

Here an instance of MBeanServeris created by the MBeanServerFactoryBeanand is supplied to the MBeanExportervia the server property. When you supply your own MBeanServerinstance, the MBeanExporterwill not attempt to locate a running MBeanServerand will use the supplied MBeanServerinstance. For this to work correctly, you must (of course) have a JMX implementation on your classpath.

31.2.2 Reusing an existing MBeanServer

If no server is specified, the MBeanExportertries to automatically detect a running MBeanServer. This works in most environment where only one MBeanServerinstance is used, however when multiple instances exist, the exporter might pick the wrong server. In such cases, one should use the MBeanServer agentIdto indicate which instance to be used:

								<beans>
								<bean
								id=
								"mbeanServer"
								class=
								"org.springframework.jmx.support.MBeanServerFactoryBean"
								>
								<!-- indicate to first look for a server -->
								<property
								name=
								"locateExistingServerIfPossible"
								value=
								"true"
								/>
								<!-- search for the MBeanServer instance with the given agentId -->
								<property
								name=
								"agentId"
								value=
								"MBeanServer_instance_agentId>"
								/>
								</bean>
								<bean
								id=
								"exporter"
								class=
								"org.springframework.jmx.export.MBeanExporter"
								>
								<property
								name=
								"server"
								ref=
								"mbeanServer"
								/>...
								</bean>
								</beans>

For platforms/cases where the existing MBeanServerhas a dynamic (or unknown) agentIdwhich is retrieved through lookup methods, one should use factory-method:

								<beans>
								<bean
								id=
								"exporter"
								class=
								"org.springframework.jmx.export.MBeanExporter"
								>
								<property
								name=
								"server"
								>
								<!-- Custom MBeanServerLocator -->
								<bean
								class=
								"platform.package.MBeanServerLocator"
								factory-method=
								"locateMBeanServer"
								/>
								</property>
								</bean>
								<!-- other beans here -->
								</beans>

31.2.3 Lazy-initialized MBeans

If you configure a bean with the MBeanExporterthat is also configured for lazy initialization, then the MBeanExporterwill notbreak this contract and will avoid instantiating the bean. Instead, it will register a proxy with the MBeanServerand will defer obtaining the bean from the container until the first invocation on the proxy occurs.

31.2.4 Automatic registration of MBeans

Any beans that are exported through the MBeanExporterand are already valid MBeans are registered as-is with the MBeanServerwithout further intervention from Spring. MBeans can be automatically detected by the MBeanExporterby setting the autodetectproperty to true:

								<bean
								id=
								"exporter"
								class=
								"org.springframework.jmx.export.MBeanExporter"
								>
								<property
								name=
								"autodetect"
								value=
								"true"
								/>
								</bean>
								<bean
								name=
								"spring:mbean=true"
								class=
								"org.springframework.jmx.export.TestDynamicMBean"
								/>

Here, the bean called spring:mbean=trueis already a valid JMX MBean and will be automatically registered by Spring. By default, beans that are autodetected for JMX registration have their bean name used as the ObjectName. This behavior can be overridden as detailed in Section 31.4, “Controlling the ObjectNames for your beans”.

31.2.5 Controlling the registration behavior

Consider the scenario where a Spring MBeanExporterattempts to register an MBeanwith an MBeanServerusing the ObjectName 'bean:name=testBean1'. If an MBeaninstance has already been registered under that same ObjectName, the default behavior is to fail (and throw an InstanceAlreadyExistsException).

It is possible to control the behavior of exactly what happens when an MBeanis registered with an MBeanServer. Spring’s JMX support allows for three different registration behaviors to control the registration behavior when the registration process finds that an MBeanhas already been registered under the same ObjectName; these registration behaviors are summarized on the following table:

Table 31.1. Registration Behaviors

Registration behavior Explanation

REGISTRATION_FAIL_ON_EXISTING

This is the default registration behavior. If an MBeaninstance has already been registered under the same ObjectName, the MBeanthat is being registered will not be registered and an InstanceAlreadyExistsExceptionwill be thrown. The existing MBeanis unaffected.

REGISTRATION_IGNORE_EXISTING

If an MBeaninstance has already been registered under the same ObjectName, the MBeanthat is being registered will notbe registered. The existing MBeanis unaffected, and no Exceptionwill be thrown. This is useful in settings where multiple applications want to share a common MBeanin a shared MBeanServer.

REGISTRATION_REPLACE_EXISTING

If an MBeaninstance has already been registered under the same ObjectName, the existing MBeanthat was previously registered will be unregistered and the new MBeanwill be registered in its place (the new MBeaneffectively replaces the previous instance).

The above values are defined as constants on the MBeanRegistrationSupportclass (the MBeanExporterclass derives from this superclass). If you want to change the default registration behavior, you simply need to set the value of the registrationBehaviorNameproperty on your MBeanExporterdefinition to one of those values.

The following example illustrates how to effect a change from the default registration behavior to the REGISTRATION_REPLACE_EXISTINGbehavior:

								<beans>
								<bean
								id=
								"exporter"
								class=
								"org.springframework.jmx.export.MBeanExporter"
								>
								<property
								name=
								"beans"
								>
								<map>
								<entry
								key=
								"bean:name=testBean1"
								value-ref=
								"testBean"
								/>
								</map>
								</property>
								<property
								name=
								"registrationBehaviorName"
								value=
								"REGISTRATION_REPLACE_EXISTING"
								/>
								</bean>
								<bean
								id=
								"testBean"
								class=
								"org.springframework.jmx.JmxTestBean"
								>
								<property
								name=
								"name"
								value=
								"TEST"
								/>
								<property
								name=
								"age"
								value=
								"100"
								/>
								</bean>
								</beans>

31.3 Controlling the management interface of your beans

In the previous example, you had little control over the management interface of your bean; allof the publicproperties and methods of each exported bean was exposed as JMX attributes and operations respectively. To exercise finer-grained control over exactly which properties and methods of your exported beans are actually exposed as JMX attributes and operations, Spring JMX provides a comprehensive and extensible mechanism for controlling the management interfaces of your beans.

31.3.1 the MBeanInfoAssembler Interface

Behind the scenes, the MBeanExporterdelegates to an implementation of the org.springframework.jmx.export.assembler.MBeanInfoAssemblerinterface which is responsible for defining the management interface of each bean that is being exposed. The default implementation, org.springframework.jmx.export.assembler.SimpleReflectiveMBeanInfoAssembler, simply defines a management interface that exposes all public properties and methods (as you saw in the previous examples). Spring provides two additional implementations of the MBeanInfoAssemblerinterface that allow you to control the generated management interface using either source-level metadata or any arbitrary interface.

31.3.2 Using Source-Level Metadata (Java annotations)

Using the MetadataMBeanInfoAssembleryou can define the management interfaces for your beans using source level metadata. The reading of metadata is encapsulated by the org.springframework.jmx.export.metadata.JmxAttributeSourceinterface. Spring JMX provides a default implementation which uses Java annotations, namely org.springframework.jmx.export.annotation.AnnotationJmxAttributeSource. The MetadataMBeanInfoAssembler mustbe configured with an implementation instance of the JmxAttributeSourceinterface for it to function correctly (there is nodefault).

To mark a bean for export to JMX, you should annotate the bean class with the ManagedResourceannotation. Each method you wish to expose as an operation must be marked with the ManagedOperationannotation and each property you wish to expose must be marked with the ManagedAttributeannotation. When marking properties you can omit either the annotation of the getter or the setter to create a write-only or read-only attribute respectively.

[Note] Note

A ManagedResourceannotated bean must be public as well as the methods exposing an operation or an attribute.

The example below shows the annotated version of the JmxTestBeanclass that you saw earlier:

								packageorg.springframework.jmx;
								importorg.springframework.jmx.export.annotation.ManagedResource;
								importorg.springframework.jmx.export.annotation.ManagedOperation;
								importorg.springframework.jmx.export.annotation.ManagedAttribute;
								
									@ManagedResource( objectName="bean:name=testBean4", description="My Managed Bean", log=true, logFile="jmx.log", currencyTimeLimit=15, persistPolicy="OnUpdate", persistPeriod=200, persistLocation="foo", persistName="bar")
								public
								classAnnotationTestBean
								implementsIJmxTestBean {
								privateString name;
								private
								intage;
								
									@ManagedAttribute(description="The Age Attribute", currencyTimeLimit=15)
								public
								intgetAge() {
								returnage; }
								public
								voidsetAge(
								intage) {
								this.age = age; }
								
									@ManagedAttribute(description="The Name Attribute", currencyTimeLimit=20, defaultValue="bar", persistPolicy="OnUpdate")
								public
								voidsetName(String name) {
								this.name = name; }
								
									@ManagedAttribute(defaultValue="foo", persistPeriod=300)
								publicString getName() {
								returnname; }
								
									@ManagedOperation(description="Add two numbers")
								
									@ManagedOperationParameters({ @ManagedOperationParameter(name = "x", description = "The first number"), @ManagedOperationParameter(name = "y", description = "The second number")})
								public
								intadd(
								intx,
								inty) {
								returnx + y; }
								public
								voiddontExposeMe() {
								throw
								newRuntimeException(); } }

Here you can see that the JmxTestBeanclass is marked with the ManagedResourceannotation and that this ManagedResourceannotation is configured with a set of properties. These properties can be used to configure various aspects of the MBean that is generated by the MBeanExporter, and are explained in greater detail later in section entitled Section 31.3.3, “Source-Level Metadata Types”.

You will also notice that both the ageand nameproperties are annotated with the ManagedAttributeannotation, but in the case of the ageproperty, only the getter is marked. This will cause both of these properties to be included in the management interface as attributes, but the ageattribute will be read-only.

Finally, you will notice that the add(int, int)method is marked with the ManagedOperationattribute whereas the dontExposeMe()method is not. This will cause the management interface to contain only one operation, add(int, int), when using the MetadataMBeanInfoAssembler.

The configuration below shows how you configure the MBeanExporterto use the MetadataMBeanInfoAssembler:

								<beans>
								<bean
								id=
								"exporter"
								class=
								"org.springframework.jmx.export.MBeanExporter"
								>
								<property
								name=
								"assembler"
								ref=
								"assembler"
								/>
								<property
								name=
								"namingStrategy"
								ref=
								"namingStrategy"
								/>
								<property
								name=
								"autodetect"
								value=
								"true"
								/>
								</bean>
								<bean
								id=
								"jmxAttributeSource"
								class=
								"org.springframework.jmx.export.annotation.AnnotationJmxAttributeSource"
								/>
								<!-- will create management interface using annotation metadata -->
								<bean
								id=
								"assembler"
								class=
								"org.springframework.jmx.export.assembler.MetadataMBeanInfoAssembler"
								>
								<property
								name=
								"attributeSource"
								ref=
								"jmxAttributeSource"
								/>
								</bean>
								<!-- will pick up the ObjectName from the annotation -->
								<bean
								id=
								"namingStrategy"
								class=
								"org.springframework.jmx.export.naming.MetadataNamingStrategy"
								>
								<property
								name=
								"attributeSource"
								ref=
								"jmxAttributeSource"
								/>
								</bean>
								<bean
								id=
								"testBean"
								class=
								"org.springframework.jmx.AnnotationTestBean"
								>
								<property
								name=
								"name"
								value=
								"TEST"
								/>
								<property
								name=
								"age"
								value=
								"100"
								/>
								</bean>
								</beans>

Here you can see that an MetadataMBeanInfoAssemblerbean has been configured with an instance of the AnnotationJmxAttributeSourceclass and passed to the MBeanExporterthrough the assembler property. This is all that is required to take advantage of metadata-driven management interfaces for your Spring-exposed MBeans.

31.3.3 Source-Level Metadata Types

The following source level metadata types are available for use in Spring JMX:

Table 31.2. Source-Level Metadata Types

Purpose Annotation Annotation Type

Mark all instances of a Classas JMX managed resources

@ManagedResource

Class

Mark a method as a JMX operation

@ManagedOperation

Method

Mark a getter or setter as one half of a JMX attribute

@ManagedAttribute

Method (only getters and setters)

Define descriptions for operation parameters

@ManagedOperationParameterand @ManagedOperationParameters

Method

The following configuration parameters are available for use on these source-level metadata types:

Table 31.3. Source-Level Metadata Parameters

Parameter Description Applies to

ObjectName

Used by MetadataNamingStrategyto determine the ObjectNameof a managed resource

ManagedResource

description

Sets the friendly description of the resource, attribute or operation

ManagedResource, ManagedAttribute, ManagedOperation, ManagedOperationParameter

currencyTimeLimit

Sets the value of the currencyTimeLimitdescriptor field

ManagedResource, ManagedAttribute

defaultValue

Sets the value of the defaultValuedescriptor field

ManagedAttribute

log

Sets the value of the logdescriptor field

ManagedResource

logFile

Sets the value of the logFiledescriptor field

ManagedResource

persistPolicy

Sets the value of the persistPolicydescriptor field

ManagedResource

persistPeriod

Sets the value of the persistPerioddescriptor field

ManagedResource

persistLocation

Sets the value of the persistLocationdescriptor field

ManagedResource

persistName

Sets the value of the persistNamedescriptor field

ManagedResource

name

Sets the display name of an operation parameter

ManagedOperationParameter

index

Sets the index of an operation parameter

ManagedOperationParameter

31.3.4 the AutodetectCapableMBeanInfoAssembler interface

To simplify configuration even further, Spring introduces the AutodetectCapableMBeanInfoAssemblerinterface which extends the MBeanInfoAssemblerinterface to add support for autodetection of MBean resources. If you configure the MBeanExporterwith an instance of AutodetectCapableMBeanInfoAssemblerthen it is allowed to "vote" on the inclusion of beans for exposure to JMX.

Out of the box, the only implementation of the AutodetectCapableMBeanInfointerface is the MetadataMBeanInfoAssemblerwhich will vote to include any bean which is marked with the ManagedResourceattribute. The default approach in this case is to use the bean name as the ObjectNamewhich results in a configuration like this:

								<beans>
								<bean
								id=
								"exporter"
								class=
								"org.springframework.jmx.export.MBeanExporter"
								>
								<!-- notice how no 'beans' are explicitly configured here -->
								<property
								name=
								"autodetect"
								value=
								"true"
								/>
								<property
								name=
								"assembler"
								ref=
								"assembler"
								/>
								</bean>
								<bean
								id=
								"testBean"
								class=
								"org.springframework.jmx.JmxTestBean"
								>
								<property
								name=
								"name"
								value=
								"TEST"
								/>
								<property
								name=
								"age"
								value=
								"100"
								/>
								</bean>
								<bean
								id=
								"assembler"
								class=
								"org.springframework.jmx.export.assembler.MetadataMBeanInfoAssembler"
								>
								<property
								name=
								"attributeSource"
								>
								<bean
								class=
								"org.springframework.jmx.export.annotation.AnnotationJmxAttributeSource"
								/>
								</property>
								</bean>
								</beans>

Notice that in this configuration no beans are passed to the MBeanExporter; however, the JmxTestBeanwill still be registered since it is marked with the ManagedResourceattribute and the MetadataMBeanInfoAssemblerdetects this and votes to include it. The only problem with this approach is that the name of the JmxTestBeannow has business meaning. You can address this issue by changing the default behavior for ObjectNamecreation as defined in Section 31.4, “Controlling the ObjectNames for your beans”.

31.3.5 Defining management interfaces using Java interfaces

In addition to the MetadataMBeanInfoAssembler, Spring also includes the InterfaceBasedMBeanInfoAssemblerwhich allows you to constrain the methods and properties that are exposed based on the set of methods defined in a collection of interfaces.

Although the standard mechanism for exposing MBeans is to use interfaces and a simple naming scheme, the InterfaceBasedMBeanInfoAssemblerextends this functionality by removing the need for naming conventions, allowing you to use more than one interface and removing the need for your beans to implement the MBean interfaces.

Consider this interface that is used to define a management interface for the JmxTestBeanclass that you saw earlier:

								public
								interfaceIJmxTestBean {
								public
								intadd(
								intx,
								inty);
								public
								longmyOperation();
								public
								intgetAge();
								public
								voidsetAge(
								intage);
								public
								voidsetName(String name);
								publicString getName(); }

This interface defines the methods and properties that will be exposed as operations and attributes on the JMX MBean. The code below shows how to configure Spring JMX to use this interface as the definition for the management interface:

								<beans>
								<bean
								id=
								"exporter"
								class=
								"org.springframework.jmx.export.MBeanExporter"
								>
								<property
								name=
								"beans"
								>
								<map>
								<entry
								key=
								"bean:name=testBean5"
								value-ref=
								"testBean"
								/>
								</map>
								</property>
								<property
								name=
								"assembler"
								>
								<bean
								class=
								"org.springframework.jmx.export.assembler.InterfaceBasedMBeanInfoAssembler"
								>
								<property
								name=
								"managedInterfaces"
								>
								<value>org.springframework.jmx.IJmxTestBean
								</value>
								</property>
								</bean>
								</property>
								</bean>
								<bean
								id=
								"testBean"
								class=
								"org.springframework.jmx.JmxTestBean"
								>
								<property
								name=
								"name"
								value=
								"TEST"
								/>
								<property
								name=
								"age"
								value=
								"100"
								/>
								</bean>
								</beans>

Here you can see that the InterfaceBasedMBeanInfoAssembleris configured to use the IJmxTestBeaninterface when constructing the management interface for any bean. It is important to understand that beans processed by the InterfaceBasedMBeanInfoAssemblerare notrequired to implement the interface used to generate the JMX management interface.

In the case above, the IJmxTestBeaninterface is used to construct all management interfaces for all beans. In many cases this is not the desired behavior and you may want to use different interfaces for different beans. In this case, you can pass InterfaceBasedMBeanInfoAssemblera Propertiesinstance via the interfaceMappingsproperty, where the key of each entry is the bean name and the value of each entry is a comma-separated list of interface names to use for that bean.

If no management interface is specified through either the managedInterfacesor interfaceMappingsproperties, then the InterfaceBasedMBeanInfoAssemblerwill reflect on the bean and use all of the interfaces implemented by that bean to create the management interface.

31.3.6 Using MethodNameBasedMBeanInfoAssembler

The MethodNameBasedMBeanInfoAssemblerallows you to specify a list of method names that will be exposed to JMX as attributes and operations. The code below shows a sample configuration for this:

								<bean
								id=
								"exporter"
								class=
								"org.springframework.jmx.export.MBeanExporter"
								>
								<property
								name=
								"beans"
								>
								<map>
								<entry
								key=
								"bean:name=testBean5"
								value-ref=
								"testBean"
								/>
								</map>
								</property>
								<property
								name=
								"assembler"
								>
								<bean
								class=
								"org.springframework.jmx.export.assembler.MethodNameBasedMBeanInfoAssembler"
								>
								<property
								name=
								"managedMethods"
								>
								<value>add,myOperation,getName,setName,getAge
								</value>
								</property>
								</bean>
								</property>
								</bean>

Here you can see that the methods addand myOperationwill be exposed as JMX operations and getName(), setName(String)and getAge()will be exposed as the appropriate half of a JMX attribute. In the code above, the method mappings apply to beans that are exposed to JMX. To control method exposure on a bean-by-bean basis, use the methodMappingsproperty of MethodNameMBeanInfoAssemblerto map bean names to lists of method names.

31.4 Controlling the ObjectNames for your beans

Behind the scenes, the MBeanExporterdelegates to an implementation of the ObjectNamingStrategyto obtain ObjectNames for each of the beans it is registering. The default implementation, KeyNamingStrategy, will, by default, use the key of the beans Mapas the ObjectName. In addition, the KeyNamingStrategycan map the key of the beans Mapto an entry in a Propertiesfile (or files) to resolve the ObjectName. In addition to the KeyNamingStrategy, Spring provides two additional ObjectNamingStrategyimplementations: the IdentityNamingStrategythat builds an ObjectNamebased on the JVM identity of the bean and the MetadataNamingStrategythat uses source level metadata to obtain the ObjectName.

31.4.1 Reading ObjectNames from Properties

You can configure your own KeyNamingStrategyinstance and configure it to read ObjectNames from a Propertiesinstance rather than use bean key. The KeyNamingStrategywill attempt to locate an entry in the Propertieswith a key corresponding to the bean key. If no entry is found or if the Propertiesinstance is nullthen the bean key itself is used.

The code below shows a sample configuration for the KeyNamingStrategy:

								<beans>
								<bean
								id=
								"exporter"
								class=
								"org.springframework.jmx.export.MBeanExporter"
								>
								<property
								name=
								"beans"
								>
								<map>
								<entry
								key=
								"testBean"
								value-ref=
								"testBean"
								/>
								</map>
								</property>
								<property
								name=
								"namingStrategy"
								ref=
								"namingStrategy"
								/>
								</bean>
								<bean
								id=
								"testBean"
								class=
								"org.springframework.jmx.JmxTestBean"
								>
								<property
								name=
								"name"
								value=
								"TEST"
								/>
								<property
								name=
								"age"
								value=
								"100"
								/>
								</bean>
								<bean
								id=
								"namingStrategy"
								class=
								"org.springframework.jmx.export.naming.KeyNamingStrategy"
								>
								<property
								name=
								"mappings"
								>
								<props>
								<prop
								key=
								"testBean"
								>bean:name=testBean1
								</prop>
								</props>
								</property>
								<property
								name=
								"mappingLocations"
								>
								<value>names1.properties,names2.properties
								</value>
								</property>
								</bean>
								</beans>

Here an instance of KeyNamingStrategyis configured with a Propertiesinstance that is merged from the Propertiesinstance defined by the mapping property and the properties files located in the paths defined by the mappings property. In this configuration, the testBeanbean will be given the ObjectName bean:name=testBean1since this is the entry in the Propertiesinstance that has a key corresponding to the bean key.

If no entry in the Propertiesinstance can be found then the bean key name is used as the ObjectName.

31.4.2 Using the MetadataNamingStrategy

The MetadataNamingStrategyuses the objectNameproperty of the ManagedResourceattribute on each bean to create the ObjectName. The code below shows the configuration for the MetadataNamingStrategy:

								<beans>
								<bean
								id=
								"exporter"
								class=
								"org.springframework.jmx.export.MBeanExporter"
								>
								<property
								name=
								"beans"
								>
								<map>
								<entry
								key=
								"testBean"
								value-ref=
								"testBean"
								/>
								</map>
								</property>
								<property
								name=
								"namingStrategy"
								ref=
								"namingStrategy"
								/>
								</bean>
								<bean
								id=
								"testBean"
								class=
								"org.springframework.jmx.JmxTestBean"
								>
								<property
								name=
								"name"
								value=
								"TEST"
								/>
								<property
								name=
								"age"
								value=
								"100"
								/>
								</bean>
								<bean
								id=
								"namingStrategy"
								class=
								"org.springframework.jmx.export.naming.MetadataNamingStrategy"
								>
								<property
								name=
								"attributeSource"
								ref=
								"attributeSource"
								/>
								</bean>
								<bean
								id=
								"attributeSource"
								class=
								"org.springframework.jmx.export.annotation.AnnotationJmxAttributeSource"
								/>
								</beans>

If no objectNamehas been provided for the ManagedResourceattribute, then an ObjectNamewill be created with the following format: [fully-qualified-package-name]:type=[short-classname],name=[bean-name]. For example, the generated ObjectNamefor the following bean would be: com.foo:type=MyClass,name=myBean.

								<bean
								id=
								"myBean"
								class=
								"com.foo.MyClass"
								/>

31.4.3 Configuring annotation based MBean export

If you prefer using the annotation based approachto define your management interfaces, then a convenience subclass of MBeanExporteris available: AnnotationMBeanExporter. When defining an instance of this subclass, the namingStrategy, assembler, and attributeSourceconfiguration is no longer needed, since it will always use standard Java annotation-based metadata (autodetection is always enabled as well). In fact, rather than defining an MBeanExporterbean, an even simpler syntax is supported by the @EnableMBeanExport @Configurationannotation.

								
									@Configuration
								
									@EnableMBeanExport
								public
								classAppConfig { }

If you prefer XML based configuration the 'context:mbean-export'element serves the same purpose.

								<context:mbean-export/>

You can provide a reference to a particular MBean serverif necessary, and the defaultDomainattribute (a property of AnnotationMBeanExporter) accepts an alternate value for the generated MBean `ObjectNames’ domains. This would be used in place of the fully qualified package name as described in the previous section on MetadataNamingStrategy.

								
									@EnableMBeanExport(server="myMBeanServer", defaultDomain="myDomain")
								
									@ConfigurationContextConfiguration { }
								<context:mbean-export
								server=
								"myMBeanServer"
								default-domain=
								"myDomain"
								/>
[Note] Note

Do not use interface-based AOP proxies in combination with autodetection of JMX annotations in your bean classes. Interface-based proxies 'hide' the target class, which also hides the JMX managed resource annotations. Hence, use target-class proxies in that case: through setting the 'proxy-target-class' flag on <aop:config/>, <tx:annotation-driven/>, etc. Otherwise, your JMX beans might be silently ignored at startup…​

31.5 JSR-160 Connectors

For remote access, Spring JMX module offers two FactoryBeanimplementations inside the org.springframework.jmx.supportpackage for creating both server- and client-side connectors.

31.5.1 Server-side Connectors

To have Spring JMX create, start and expose a JSR-160 JMXConnectorServeruse the following configuration:

								<bean
								id=
								"serverConnector"
								class=
								"org.springframework.jmx.support.ConnectorServerFactoryBean"
								/>

By default ConnectorServerFactoryBeancreates a JMXConnectorServerbound to "service:jmx:jmxmp://localhost:9875". The serverConnectorbean thus exposes the local MBeanServerto clients through the JMXMP protocol on localhost, port 9875. Note that the JMXMP protocol is marked as optional by the JSR 160 specification: currently, the main open-source JMX implementation, MX4J, and the one provided with the JDK do notsupport JMXMP.

To specify another URL and register the JMXConnectorServeritself with the MBeanServeruse the serviceUrland ObjectNameproperties respectively:

								<bean
								id=
								"serverConnector"
								class=
								"org.springframework.jmx.support.ConnectorServerFactoryBean"
								>
								<property
								name=
								"objectName"
								value=
								"connector:name=rmi"
								/>
								<property
								name=
								"serviceUrl"
								value=
								"service:jmx:rmi://localhost/jndi/rmi://localhost:1099/myconnector"
								/>
								</bean>

If the ObjectNameproperty is set Spring will automatically register your connector with the MBeanServerunder that ObjectName. The example below shows the full set of parameters which you can pass to the ConnectorServerFactoryBeanwhen creating a JMXConnector:

								<bean
								id=
								"serverConnector"
								class=
								"org.springframework.jmx.support.ConnectorServerFactoryBean"
								>
								<property
								name=
								"objectName"
								value=
								"connector:name=iiop"
								/>
								<property
								name=
								"serviceUrl"
								value=
								"service:jmx:iiop://localhost/jndi/iiop://localhost:900/myconnector"
								/>
								<property
								name=
								"threaded"
								value=
								"true"
								/>
								<property
								name=
								"daemon"
								value=
								"true"
								/>
								<property
								name=
								"environment"
								>
								<map>
								<entry
								key=
								"someKey"
								value=
								"someValue"
								/>
								</map>
								</property>
								</bean>

Note that when using a RMI-based connector you need the lookup service (tnameserv or rmiregistry) to be started in order for the name registration to complete. If you are using Spring to export remote services for you via RMI, then Spring will already have constructed an RMI registry. If not, you can easily start a registry using the following snippet of configuration:

								<bean
								id=
								"registry"
								class=
								"org.springframework.remoting.rmi.RmiRegistryFactoryBean"
								>
								<property
								name=
								"port"
								value=
								"1099"
								/>
								</bean>

31.5.2 Client-side Connectors

To create an MBeanServerConnectionto a remote JSR-160 enabled MBeanServeruse the MBeanServerConnectionFactoryBeanas shown below:

								<bean
								id=
								"clientConnector"
								class=
								"org.springframework.jmx.support.MBeanServerConnectionFactoryBean"
								>
								<property
								name=
								"serviceUrl"
								value=
								"service:jmx:rmi://localhost/jndi/rmi://localhost:1099/jmxrmi"
								/>
								</bean>

31.5.3 JMX over Burlap/Hessian/SOAP

JSR-160 permits extensions to the way in which communication is done between the client and the server. The examples above are using the mandatory RMI-based implementation required by the JSR-160 specification (IIOP and JRMP) and the (optional) JMXMP. By using other providers or JMX implementations (such as MX4J) you can take advantage of protocols like SOAP, Hessian, Burlap over simple HTTP or SSL and others:

								<bean
								id=
								"serverConnector"
								class=
								"org.springframework.jmx.support.ConnectorServerFactoryBean"
								>
								<property
								name=
								"objectName"
								value=
								"connector:name=burlap"
								/>
								<property
								name=
								"serviceUrl"
								value=
								"service:jmx:burlap://localhost:9874"
								/>
								</bean>

In the case of the above example, MX4J 3.0.0 was used; see the official MX4J documentation for more information.

31.6 Accessing MBeans via Proxies

Spring JMX allows you to create proxies that re-route calls to MBeans registered in a local or remote MBeanServer. These proxies provide you with a standard Java interface through which you can interact with your MBeans. The code below shows how to configure a proxy for an MBean running in a local MBeanServer:

							<bean
							id=
							"proxy"
							class=
							"org.springframework.jmx.access.MBeanProxyFactoryBean"
							>
							<property
							name=
							"objectName"
							value=
							"bean:name=testBean"
							/>
							<property
							name=
							"proxyInterface"
							value=
							"org.springframework.jmx.IJmxTestBean"
							/>
							</bean>

Here you can see that a proxy is created for the MBean registered under the ObjectName: bean:name=testBean. The set of interfaces that the proxy will implement is controlled by the proxyInterfacesproperty and the rules for mapping methods and properties on these interfaces to operations and attributes on the MBean are the same rules used by the InterfaceBasedMBeanInfoAssembler.

The MBeanProxyFactoryBeancan create a proxy to any MBean that is accessible via an MBeanServerConnection. By default, the local MBeanServeris located and used, but you can override this and provide an MBeanServerConnectionpointing to a remote MBeanServerto cater for proxies pointing to remote MBeans:

							<bean
							id=
							"clientConnector"
							class=
							"org.springframework.jmx.support.MBeanServerConnectionFactoryBean"
							>
							<property
							name=
							"serviceUrl"
							value=
							"service:jmx:rmi://remotehost:9875"
							/>
							</bean>
							<bean
							id=
							"proxy"
							class=
							"org.springframework.jmx.access.MBeanProxyFactoryBean"
							>
							<property
							name=
							"objectName"
							value=
							"bean:name=testBean"
							/>
							<property
							name=
							"proxyInterface"
							value=
							"org.springframework.jmx.IJmxTestBean"
							/>
							<property
							name=
							"server"
							ref=
							"clientConnector"
							/>
							</bean>

Here you can see that we create an MBeanServerConnectionpointing to a remote machine using the MBeanServerConnectionFactoryBean. This MBeanServerConnectionis then passed to the MBeanProxyFactoryBeanvia the serverproperty. The proxy that is created will forward all invocations to the MBeanServervia this MBeanServerConnection.

31.7 Notifications

Spring’s JMX offering includes comprehensive support for JMX notifications.

31.7.1 Registering Listeners for Notifications

Spring’s JMX support makes it very easy to register any number of NotificationListenerswith any number of MBeans (this includes MBeans exported by Spring’s MBeanExporterand MBeans registered via some other mechanism). By way of an example, consider the scenario where one would like to be informed (via a Notification) each and every time an attribute of a target MBean changes.

								packagecom.example;
								importjavax.management.AttributeChangeNotification;
								importjavax.management.Notification;
								importjavax.management.NotificationFilter;
								importjavax.management.NotificationListener;
								public
								classConsoleLoggingNotificationListener
								implementsNotificationListener, NotificationFilter {
								public
								voidhandleNotification(Notification notification, Object handback) { System.out.println(notification); System.out.println(handback); }
								public
								booleanisNotificationEnabled(Notification notification) {
								returnAttributeChangeNotification.
								class.isAssignableFrom(notification.getClass()); } }
								<beans>
								<bean
								id=
								"exporter"
								class=
								"org.springframework.jmx.export.MBeanExporter"
								>
								<property
								name=
								"beans"
								>
								<map>
								<entry
								key=
								"bean:name=testBean1"
								value-ref=
								"testBean"
								/>
								</map>
								</property>
								<property
								name=
								"notificationListenerMappings"
								>
								<map>
								<entry
								key=
								"bean:name=testBean1"
								>
								<bean
								class=
								"com.example.ConsoleLoggingNotificationListener"
								/>
								</entry>
								</map>
								</property>
								</bean>
								<bean
								id=
								"testBean"
								class=
								"org.springframework.jmx.JmxTestBean"
								>
								<property
								name=
								"name"
								value=
								"TEST"
								/>
								<property
								name=
								"age"
								value=
								"100"
								/>
								</bean>
								</beans>

With the above configuration in place, every time a JMX Notificationis broadcast from the target MBean ( bean:name=testBean1), the ConsoleLoggingNotificationListenerbean that was registered as a listener via the notificationListenerMappingsproperty will be notified. The ConsoleLoggingNotificationListenerbean can then take whatever action it deems appropriate in response to the Notification.

You can also use straight bean names as the link between exported beans and listeners:

								<beans>
								<bean
								id=
								"exporter"
								class=
								"org.springframework.jmx.export.MBeanExporter"
								>
								<property
								name=
								"beans"
								>
								<map>
								<entry
								key=
								"bean:name=testBean1"
								value-ref=
								"testBean"
								/>
								</map>
								</property>
								<property
								name=
								"notificationListenerMappings"
								>
								<map>
								<entry
								key=
								"
								
									testBean">
								<bean
								class=
								"com.example.ConsoleLoggingNotificationListener"
								/>
								</entry>
								</map>
								</property>
								</bean>
								<bean
								id=
								"
								
									testBean" class="org.springframework.jmx.JmxTestBean">
								<property
								name=
								"name"
								value=
								"TEST"
								/>
								<property
								name=
								"age"
								value=
								"100"
								/>
								</bean>
								</beans>

If one wants to register a single NotificationListenerinstance for all of the beans that the enclosing MBeanExporteris exporting, one can use the special wildcard '*'(sans quotes) as the key for an entry in the notificationListenerMappingsproperty map; for example:

								<property
								name=
								"notificationListenerMappings"
								>
								<map>
								<entry
								key=
								"*"
								>
								<bean
								class=
								"com.example.ConsoleLoggingNotificationListener"
								/>
								</entry>
								</map>
								</property>

If one needs to do the inverse (that is, register a number of distinct listeners against an MBean), then one has to use the notificationListenerslist property instead (and in preference to the notificationListenerMappingsproperty). This time, instead of configuring simply a NotificationListenerfor a single MBean, one configures NotificationListenerBeaninstances…​ a NotificationListenerBeanencapsulates a NotificationListenerand the ObjectName(or ObjectNames) that it is to be registered against in an MBeanServer. The NotificationListenerBeanalso encapsulates a number of other properties such as a NotificationFilterand an arbitrary handback object that can be used in advanced JMX notification scenarios.

The configuration when using NotificationListenerBeaninstances is not wildly different to what was presented previously:

								<beans>
								<bean
								id=
								"exporter"
								class=
								"org.springframework.jmx.export.MBeanExporter"
								>
								<property
								name=
								"beans"
								>
								<map>
								<entry
								key=
								"bean:name=testBean1"
								value-ref=
								"testBean"
								/>
								</map>
								</property>
								<property
								name=
								"notificationListeners"
								>
								<list>
								<bean
								class=
								"org.springframework.jmx.export.NotificationListenerBean"
								>
								<constructor-arg>
								<bean
								class=
								"com.example.ConsoleLoggingNotificationListener"
								/>
								</constructor-arg>
								<property
								name=
								"mappedObjectNames"
								>
								<list>
								<value>bean:name=testBean1
								</value>
								</list>
								</property>
								</bean>
								</list>
								</property>
								</bean>
								<bean
								id=
								"testBean"
								class=
								"org.springframework.jmx.JmxTestBean"
								>
								<property
								name=
								"name"
								value=
								"TEST"
								/>
								<property
								name=
								"age"
								value=
								"100"
								/>
								</bean>
								</beans>

The above example is equivalent to the first notification example. Lets assume then that we want to be given a handback object every time a Notificationis raised, and that additionally we want to filter out extraneous Notificationsby supplying a NotificationFilter. (For a full discussion of just what a handback object is, and indeed what a NotificationFilteris, please do consult that section of the JMX specification (1.2) entitled 'The JMX Notification Model'.)

								<beans>
								<bean
								id=
								"exporter"
								class=
								"org.springframework.jmx.export.MBeanExporter"
								>
								<property
								name=
								"beans"
								>
								<map>
								<entry
								key=
								"bean:name=testBean1"
								value-ref=
								"testBean1"
								/>
								<entry
								key=
								"bean:name=testBean2"
								value-ref=
								"testBean2"
								/>
								</map>
								</property>
								<property
								name=
								"notificationListeners"
								>
								<list>
								<bean
								class=
								"org.springframework.jmx.export.NotificationListenerBean"
								>
								<constructor-arg
								ref=
								"customerNotificationListener"
								/>
								<property
								name=
								"mappedObjectNames"
								>
								<list>
								<!-- handles notifications from two distinct MBeans -->
								<value>bean:name=testBean1
								</value>
								<value>bean:name=testBean2
								</value>
								</list>
								</property>
								<property
								name=
								"handback"
								>
								<bean
								class=
								"java.lang.String"
								>
								<constructor-arg
								value=
								"This could be anything..."
								/>
								</bean>
								</property>
								<property
								name=
								"notificationFilter"
								ref=
								"customerNotificationListener"
								/>
								</bean>
								</list>
								</property>
								</bean>
								<!-- implements both the NotificationListener and NotificationFilter interfaces -->
								<bean
								id=
								"customerNotificationListener"
								class=
								"com.example.ConsoleLoggingNotificationListener"
								/>
								<bean
								id=
								"testBean1"
								class=
								"org.springframework.jmx.JmxTestBean"
								>
								<property
								name=
								"name"
								value=
								"TEST"
								/>
								<property
								name=
								"age"
								value=
								"100"
								/>
								</bean>
								<bean
								id=
								"testBean2"
								class=
								"org.springframework.jmx.JmxTestBean"
								>
								<property
								name=
								"name"
								value=
								"ANOTHER TEST"
								/>
								<property
								name=
								"age"
								value=
								"200"
								/>
								</bean>
								</beans>

31.7.2 Publishing Notifications

Spring provides support not just for registering to receive Notifications, but also for publishing Notifications.

[Note] Note

Please note that this section is really only relevant to Spring managed beans that have been exposed as MBeans via an MBeanExporter; any existing, user-defined MBeans should use the standard JMX APIs for notification publication.

The key interface in Spring’s JMX notification publication support is the NotificationPublisherinterface (defined in the org.springframework.jmx.export.notificationpackage). Any bean that is going to be exported as an MBean via an MBeanExporterinstance can implement the related NotificationPublisherAwareinterface to gain access to a NotificationPublisherinstance. The NotificationPublisherAwareinterface simply supplies an instance of a NotificationPublisherto the implementing bean via a simple setter method, which the bean can then use to publish Notifications.

As stated in the javadocs of the NotificationPublisherclass, managed beans that are publishing events via the NotificationPublishermechanism are notresponsible for the state management of any notification listeners and the like …​ Spring’s JMX support will take care of handling all the JMX infrastructure issues. All one need do as an application developer is implement the NotificationPublisherAwareinterface and start publishing events using the supplied NotificationPublisherinstance. Note that the NotificationPublisherwill be set afterthe managed bean has been registered with an MBeanServer.

Using a NotificationPublisherinstance is quite straightforward…​ one simply creates a JMX Notificationinstance (or an instance of an appropriate Notificationsubclass), populates the notification with the data pertinent to the event that is to be published, and one then invokes the sendNotification(Notification)on the NotificationPublisherinstance, passing in the Notification.

Find below a simple example…​ in this scenario, exported instances of the JmxTestBeanare going to publish a NotificationEventevery time the add(int, int)operation is invoked.

								packageorg.springframework.jmx;
								importorg.springframework.jmx.export.notification.NotificationPublisherAware;
								importorg.springframework.jmx.export.notification.NotificationPublisher;
								importjavax.management.Notification;
								public
								classJmxTestBean
								implementsIJmxTestBean, NotificationPublisherAware {
								privateString name;
								private
								intage;
								private
								booleanisSuperman;
								privateNotificationPublisher publisher;
								// other getters and setters omitted for clarity
								public
								intadd(
								intx,
								inty) {
								intanswer = x + y;
								this.publisher.sendNotification(
								newNotification(
								"add",
								this,
								0));
								returnanswer; }
								public
								voiddontExposeMe() {
								throw
								newRuntimeException(); }
								public
								voidsetNotificationPublisher(NotificationPublisher notificationPublisher) {
								this.publisher = notificationPublisher; } }

The NotificationPublisherinterface and the machinery to get it all working is one of the nicer features of Spring’s JMX support. It does however come with the price tag of coupling your classes to both Spring and JMX; as always, the advice here is to be pragmatic…​ if you need the functionality offered by the NotificationPublisherand you can accept the coupling to both Spring and JMX, then do so.

31.8 Further Resources

This section contains links to further resources about JMX.

32. JCA CCI

32.1 Introduction

Java EE provides a specification to standardize access to enterprise information systems (EIS): the JCA (Java EE Connector Architecture). This specification is divided into several different parts:

  • SPI (Service provider interfaces) that the connector provider must implement. These interfaces constitute a resource adapter which can be deployed on a Java EE application server. In such a scenario, the server manages connection pooling, transaction and security (managed mode). The application server is also responsible for managing the configuration, which is held outside the client application. A connector can be used without an application server as well; in this case, the application must configure it directly (non-managed mode).
  • CCI (Common Client Interface) that an application can use to interact with the connector and thus communicate with an EIS. An API for local transaction demarcation is provided as well.

The aim of the Spring CCI support is to provide classes to access a CCI connector in typical Spring style, leveraging the Spring Framework’s general resource and transaction management facilities.

[Note] Note

The client side of connectors doesn’t alway use CCI. Some connectors expose their own APIs, only providing JCA resource adapter to use the system contracts of a Java EE container (connection pooling, global transactions, security). Spring does not offer special support for such connector-specific APIs.

32.2 Configuring CCI

32.2.1 Connector configuration

The base resource to use JCA CCI is the ConnectionFactoryinterface. The connector used must provide an implementation of this interface.

To use your connector, you can deploy it on your application server and fetch the ConnectionFactoryfrom the server’s JNDI environment (managed mode). The connector must be packaged as a RAR file (resource adapter archive) and contain a ra.xmlfile to describe its deployment characteristics. The actual name of the resource is specified when you deploy it. To access it within Spring, simply use Spring’s JndiObjectFactoryBean/ <jee:jndi-lookup>fetch the factory by its JNDI name.

Another way to use a connector is to embed it in your application (non-managed mode), not using an application server to deploy and configure it. Spring offers the possibility to configure a connector as a bean, through a provided FactoryBean( LocalConnectionFactoryBean). In this manner, you only need the connector library in the classpath (no RAR file and no ra.xmldescriptor needed). The library must be extracted from the connector’s RAR file, if necessary.

Once you have got access to your ConnectionFactoryinstance, you can inject it into your components. These components can either be coded against the plain CCI API or leverage Spring’s support classes for CCI access (e.g. CciTemplate).

[Note] Note

When you use a connector in non-managed mode, you can’t use global transactions because the resource is never enlisted / delisted in the current global transaction of the current thread. The resource is simply not aware of any global Java EE transactions that might be running.

32.2.2 ConnectionFactory configuration in Spring

In order to make connections to the EIS, you need to obtain a ConnectionFactoryfrom the application server if you are in a managed mode, or directly from Spring if you are in a non-managed mode.

In a managed mode, you access a ConnectionFactoryfrom JNDI; its properties will be configured in the application server.

								<jee:jndi-lookup
								id=
								"eciConnectionFactory"
								jndi-name=
								"eis/cicseci"
								/>

In non-managed mode, you must configure the ConnectionFactoryyou want to use in the configuration of Spring as a JavaBean. The LocalConnectionFactoryBeanclass offers this setup style, passing in the ManagedConnectionFactoryimplementation of your connector, exposing the application-level CCI ConnectionFactory.

								<bean
								id=
								"eciManagedConnectionFactory"
								class=
								"com.ibm.connector2.cics.ECIManagedConnectionFactory"
								>
								<property
								name=
								"serverName"
								value=
								"TXSERIES"
								/>
								<property
								name=
								"connectionURL"
								value=
								"tcp://localhost/"
								/>
								<property
								name=
								"portNumber"
								value=
								"2006"
								/>
								</bean>
								<bean
								id=
								"eciConnectionFactory"
								class=
								"org.springframework.jca.support.LocalConnectionFactoryBean"
								>
								<property
								name=
								"managedConnectionFactory"
								ref=
								"eciManagedConnectionFactory"
								/>
								</bean>
[Note] Note

You can’t directly instantiate a specific ConnectionFactory. You need to go through the corresponding implementation of the ManagedConnectionFactoryinterface for your connector. This interface is part of the JCA SPI specification.

32.2.3 Configuring CCI connections

JCA CCI allow the developer to configure the connections to the EIS using the ConnectionSpecimplementation of your connector. In order to configure its properties, you need to wrap the target connection factory with a dedicated adapter, ConnectionSpecConnectionFactoryAdapter. So, the dedicated ConnectionSpeccan be configured with the property connectionSpec(as an inner bean).

This property is not mandatory because the CCI ConnectionFactoryinterface defines two different methods to obtain a CCI connection. Some of the ConnectionSpecproperties can often be configured in the application server (in managed mode) or on the corresponding local ManagedConnectionFactoryimplementation.

								public
								interfaceConnectionFactory
								implementsSerializable, Referenceable { ... Connection getConnection()
								throwsResourceException; Connection getConnection(ConnectionSpec connectionSpec)
								throwsResourceException; ... }

Spring provides a ConnectionSpecConnectionFactoryAdapterthat allows for specifying a ConnectionSpecinstance to use for all operations on a given factory. If the adapter’s connectionSpecproperty is specified, the adapter uses the getConnectionvariant with the ConnectionSpecargument, otherwise the variant without argument.

								<bean
								id=
								"managedConnectionFactory"
								class=
								"com.sun.connector.cciblackbox.CciLocalTxManagedConnectionFactory"
								>
								<property
								name=
								"connectionURL"
								value=
								"jdbc:hsqldb:hsql://localhost:9001"
								/>
								<property
								name=
								"driverName"
								value=
								"org.hsqldb.jdbcDriver"
								/>
								</bean>
								<bean
								id=
								"targetConnectionFactory"
								class=
								"org.springframework.jca.support.LocalConnectionFactoryBean"
								>
								<property
								name=
								"managedConnectionFactory"
								ref=
								"managedConnectionFactory"
								/>
								</bean>
								<bean
								id=
								"connectionFactory"
								class=
								"org.springframework.jca.cci.connection.ConnectionSpecConnectionFactoryAdapter"
								>
								<property
								name=
								"targetConnectionFactory"
								ref=
								"targetConnectionFactory"
								/>
								<property
								name=
								"connectionSpec"
								>
								<bean
								class=
								"com.sun.connector.cciblackbox.CciConnectionSpec"
								>
								<property
								name=
								"user"
								value=
								"sa"
								/>
								<property
								name=
								"password"
								value=
								""
								/>
								</bean>
								</property>
								</bean>

32.2.4 Using a single CCI connection

If you want to use a single CCI connection, Spring provides a further ConnectionFactoryadapter to manage this. The SingleConnectionFactoryadapter class will open a single connection lazily and close it when this bean is destroyed at application shutdown. This class will expose special Connectionproxies that behave accordingly, all sharing the same underlying physical connection.

								<bean
								id=
								"eciManagedConnectionFactory"
								class=
								"com.ibm.connector2.cics.ECIManagedConnectionFactory"
								>
								<property
								name=
								"serverName"
								value=
								"TEST"
								/>
								<property
								name=
								"connectionURL"
								value=
								"tcp://localhost/"
								/>
								<property
								name=
								"portNumber"
								value=
								"2006"
								/>
								</bean>
								<bean
								id=
								"targetEciConnectionFactory"
								class=
								"org.springframework.jca.support.LocalConnectionFactoryBean"
								>
								<property
								name=
								"managedConnectionFactory"
								ref=
								"eciManagedConnectionFactory"
								/>
								</bean>
								<bean
								id=
								"eciConnectionFactory"
								class=
								"org.springframework.jca.cci.connection.SingleConnectionFactory"
								>
								<property
								name=
								"targetConnectionFactory"
								ref=
								"targetEciConnectionFactory"
								/>
								</bean>
[Note] Note

This ConnectionFactoryadapter cannot directly be configured with a ConnectionSpec. Use an intermediary ConnectionSpecConnectionFactoryAdapterthat the SingleConnectionFactorytalks to if you require a single connection for a specific ConnectionSpec.

32.3 Using Spring’s CCI access support

32.3.1 Record conversion

One of the aims of the JCA CCI support is to provide convenient facilities for manipulating CCI records. The developer can specify the strategy to create records and extract datas from records, for use with Spring’s CciTemplate. The following interfaces will configure the strategy to use input and output records if you don’t want to work with records directly in your application.

In order to create an input Record, the developer can use a dedicated implementation of the RecordCreatorinterface.

								public
								interfaceRecordCreator { Record createRecord(RecordFactory recordFactory)
								throwsResourceException, DataAccessException; }

As you can see, the createRecord(..)method receives a RecordFactoryinstance as parameter, which corresponds to the RecordFactoryof the ConnectionFactoryused. This reference can be used to create IndexedRecordor MappedRecordinstances. The following sample shows how to use the RecordCreatorinterface and indexed/mapped records.

								public
								classMyRecordCreator
								implementsRecordCreator {
								publicRecord createRecord(RecordFactory recordFactory)
								throwsResourceException { IndexedRecord input = recordFactory.createIndexedRecord(
								"input"); input.add(
								newInteger(id));
								returninput; } }

An output Recordcan be used to receive data back from the EIS. Hence, a specific implementation of the RecordExtractorinterface can be passed to Spring’s CciTemplatefor extracting data from the output Record.

								public
								interfaceRecordExtractor { Object extractData(Record record)
								throwsResourceException, SQLException, DataAccessException; }

The following sample shows how to use the RecordExtractorinterface.

								public
								classMyRecordExtractor
								implementsRecordExtractor {
								publicObject extractData(Record record)
								throwsResourceException { CommAreaRecord commAreaRecord = (CommAreaRecord) record; String str =
								newString(commAreaRecord.toByteArray()); String field1 = string.substring(
								0,
								6); String field2 = string.substring(
								6,
								1);
								return
								newOutputObject(Long.parseLong(field1), field2); } }

32.3.2 the CciTemplate

The CciTemplateis the central class of the core CCI support package ( org.springframework.jca.cci.core). It simplifies the use of CCI since it handles the creation and release of resources. This helps to avoid common errors like forgetting to always close the connection. It cares for the lifecycle of connection and interaction objects, letting application code focus on generating input records from application data and extracting application data from output records.

The JCA CCI specification defines two distinct methods to call operations on an EIS. The CCI Interactioninterface provides two execute method signatures:

								public
								interfacejavax.resource.cci.Interaction { ...
								booleanexecute(InteractionSpec spec, Record input, Record output)
								throwsResourceException; Record execute(InteractionSpec spec, Record input)
								throwsResourceException; ... }

Depending on the template method called, CciTemplatewill know which executemethod to call on the interaction. In any case, a correctly initialized InteractionSpecinstance is mandatory.

CciTemplate.execute(..)can be used in two ways:

  • With direct Recordarguments. In this case, you simply need to pass the CCI input record in, and the returned object be the corresponding CCI output record.
  • With application objects, using record mapping. In this case, you need to provide corresponding RecordCreatorand RecordExtractorinstances.

With the first approach, the following methods of the template will be used. These methods directly correspond to those on the Interactioninterface.

								public
								classCciTemplate
								implementsCciOperations {
								publicRecord execute(InteractionSpec spec, Record inputRecord)
								throwsDataAccessException { ... }
								public
								voidexecute(InteractionSpec spec, Record inputRecord, Record outputRecord)
								throwsDataAccessException { ... } }

With the second approach, we need to specify the record creation and record extraction strategies as arguments. The interfaces used are those describe in the previous section on record conversion. The corresponding CciTemplatemethods are the following:

								public
								classCciTemplate
								implementsCciOperations {
								publicRecord execute(InteractionSpec spec, RecordCreator inputCreator)
								throwsDataAccessException {
								// ...}
								publicObject execute(InteractionSpec spec, Record inputRecord, RecordExtractor outputExtractor)
								throwsDataAccessException {
								// ...}
								publicObject execute(InteractionSpec spec, RecordCreator creator, RecordExtractor extractor)
								throwsDataAccessException {
								// ...} }

Unless the outputRecordCreatorproperty is set on the template (see the following section), every method will call the corresponding executemethod of the CCI Interactionwith two parameters: InteractionSpecand input Record, receiving an output Recordas return value.

CciTemplatealso provides methods to create IndexRecordand MappedRecordoutside a RecordCreatorimplementation, through its createIndexRecord(..)and createMappedRecord(..)methods. This can be used within DAO implementations to create Recordinstances to pass into corresponding CciTemplate.execute(..)methods.

								public
								classCciTemplate
								implementsCciOperations {
								publicIndexedRecord createIndexedRecord(String name)
								throwsDataAccessException { ... }
								publicMappedRecord createMappedRecord(String name)
								throwsDataAccessException { ... } }

32.3.3 DAO support

Spring’s CCI support provides a abstract class for DAOs, supporting injection of a ConnectionFactoryor a CciTemplateinstances. The name of the class is CciDaoSupport: It provides simple setConnectionFactoryand setCciTemplatemethods. Internally, this class will create a CciTemplateinstance for a passed-in ConnectionFactory, exposing it to concrete data access implementations in subclasses.

								public
								abstract
								classCciDaoSupport {
								public
								voidsetConnectionFactory(ConnectionFactory connectionFactory) {
								// ...}
								publicConnectionFactory getConnectionFactory() {
								// ...}
								public
								voidsetCciTemplate(CciTemplate cciTemplate) {
								// ...}
								publicCciTemplate getCciTemplate() {
								// ...} }

32.3.4 Automatic output record generation

If the connector used only supports the Interaction.execute(..)method with input and output records as parameters (that is, it requires the desired output record to be passed in instead of returning an appropriate output record), you can set the outputRecordCreatorproperty of the CciTemplateto automatically generate an output record to be filled by the JCA connector when the response is received. This record will be then returned to the caller of the template.

This property simply holds an implementation of the RecordCreatorinterface, used for that purpose. The RecordCreatorinterface has already been discussed in Section 32.3.1, “Record conversion”. The outputRecordCreatorproperty must be directly specified on the CciTemplate. This could be done in the application code like so:

cciTemplate.setOutputRecordCreator(
								newEciOutputRecordCreator());

Or (recommended) in the Spring configuration, if the CciTemplateis configured as a dedicated bean instance:

								<bean
								id=
								"eciOutputRecordCreator"
								class=
								"eci.EciOutputRecordCreator"
								/>
								<bean
								id=
								"cciTemplate"
								class=
								"org.springframework.jca.cci.core.CciTemplate"
								>
								<property
								name=
								"connectionFactory"
								ref=
								"eciConnectionFactory"
								/>
								<property
								name=
								"outputRecordCreator"
								ref=
								"eciOutputRecordCreator"
								/>
								</bean>
[Note] Note

As the CciTemplateclass is thread-safe, it will usually be configured as a shared instance.

32.3.5 Summary

The following table summarizes the mechanisms of the CciTemplateclass and the corresponding methods called on the CCI Interactioninterface:

Table 32.1. Usage of Interaction execute methods

CciTemplate method signature CciTemplate outputRecordCreator property execute method called on the CCI Interaction

Record execute(InteractionSpec, Record)

not set

Record execute(InteractionSpec, Record)

Record execute(InteractionSpec, Record)

set

boolean execute(InteractionSpec, Record, Record)

void execute(InteractionSpec, Record, Record)

not set

void execute(InteractionSpec, Record, Record)

void execute(InteractionSpec, Record, Record)

set

void execute(InteractionSpec, Record, Record)

Record execute(InteractionSpec, RecordCreator)

not set

Record execute(InteractionSpec, Record)

Record execute(InteractionSpec, RecordCreator)

set

void execute(InteractionSpec, Record, Record)

Record execute(InteractionSpec, Record, RecordExtractor)

not set

Record execute(InteractionSpec, Record)

Record execute(InteractionSpec, Record, RecordExtractor)

set

void execute(InteractionSpec, Record, Record)

Record execute(InteractionSpec, RecordCreator, RecordExtractor)

not set

Record execute(InteractionSpec, Record)

Record execute(InteractionSpec, RecordCreator, RecordExtractor)

set

void execute(InteractionSpec, Record, Record)

32.3.6 Using a CCI Connection and Interaction directly

CciTemplatealso offers the possibility to work directly with CCI connections and interactions, in the same manner as JdbcTemplateand JmsTemplate. This is useful when you want to perform multiple operations on a CCI connection or interaction, for example.

The interface ConnectionCallbackprovides a CCI Connectionas argument, in order to perform custom operations on it, plus the CCI ConnectionFactorywhich the Connectionwas created with. The latter can be useful for example to get an associated RecordFactoryinstance and create indexed/mapped records, for example.

								public
								interfaceConnectionCallback { Object doInConnection(Connection connection, ConnectionFactory connectionFactory)
								throwsResourceException, SQLException, DataAccessException; }

The interface InteractionCallbackprovides the CCI Interaction, in order to perform custom operations on it, plus the corresponding CCI ConnectionFactory.

								public
								interfaceInteractionCallback { Object doInInteraction(Interaction interaction, ConnectionFactory connectionFactory)
								throwsResourceException, SQLException, DataAccessException; }
[Note] Note

InteractionSpecobjects can either be shared across multiple template calls or newly created inside every callback method. This is completely up to the DAO implementation.

32.3.7 Example for CciTemplate usage

In this section, the usage of the CciTemplatewill be shown to acces to a CICS with ECI mode, with the IBM CICS ECI connector.

Firstly, some initializations on the CCI InteractionSpecmust be done to specify which CICS program to access and how to interact with it.

ECIInteractionSpec interactionSpec =
								newECIInteractionSpec(); interactionSpec.setFunctionName(
								"MYPROG"); interactionSpec.setInteractionVerb(ECIInteractionSpec.SYNC_SEND_RECEIVE);

Then the program can use CCI via Spring’s template and specify mappings between custom objects and CCI Records.

								public
								classMyDaoImpl
								extendsCciDaoSupport
								implementsMyDao {
								publicOutputObject getData(InputObject input) { ECIInteractionSpec interactionSpec = ...; OutputObject output = (ObjectOutput) getCciTemplate().execute(interactionSpec,
								newRecordCreator() {
								publicRecord createRecord(RecordFactory recordFactory)
								throwsResourceException {
								return
								newCommAreaRecord(input.toString().getBytes()); } },
								newRecordExtractor() {
								publicObject extractData(Record record)
								throwsResourceException { CommAreaRecord commAreaRecord = (CommAreaRecord)record; String str =
								newString(commAreaRecord.toByteArray()); String field1 = string.substring(
								0,
								6); String field2 = string.substring(
								6,
								1);
								return
								newOutputObject(Long.parseLong(field1), field2); } });
								returnoutput; } }

As discussed previously, callbacks can be used to work directly on CCI connections or interactions.

								public
								classMyDaoImpl
								extendsCciDaoSupport
								implementsMyDao {
								publicOutputObject getData(InputObject input) { ObjectOutput output = (ObjectOutput) getCciTemplate().execute(
								newConnectionCallback() {
								publicObject doInConnection(Connection connection, ConnectionFactory factory)
								throwsResourceException {
								// do something...} }); }
								returnoutput; } }
[Note] Note

With a ConnectionCallback, the Connectionused will be managed and closed by the CciTemplate, but any interactions created on the connection must be managed by the callback implementation.

For a more specific callback, you can implement an InteractionCallback. The passed-in Interactionwill be managed and closed by the CciTemplatein this case.

								public
								classMyDaoImpl
								extendsCciDaoSupport
								implementsMyDao {
								publicString getData(String input) { ECIInteractionSpec interactionSpec = ...; String output = (String) getCciTemplate().execute(interactionSpec,
								newInteractionCallback() {
								publicObject doInInteraction(Interaction interaction, ConnectionFactory factory)
								throwsResourceException { Record input =
								newCommAreaRecord(inputString.getBytes()); Record output =
								newCommAreaRecord(); interaction.execute(holder.getInteractionSpec(), input, output);
								return
								newString(output.toByteArray()); } });
								returnoutput; } }

For the examples above, the corresponding configuration of the involved Spring beans could look like this in non-managed mode:

								<bean
								id=
								"managedConnectionFactory"
								class=
								"com.ibm.connector2.cics.ECIManagedConnectionFactory"
								>
								<property
								name=
								"serverName"
								value=
								"TXSERIES"
								/>
								<property
								name=
								"connectionURL"
								value=
								"local:"
								/>
								<property
								name=
								"userName"
								value=
								"CICSUSER"
								/>
								<property
								name=
								"password"
								value=
								"CICS"
								/>
								</bean>
								<bean
								id=
								"connectionFactory"
								class=
								"org.springframework.jca.support.LocalConnectionFactoryBean"
								>
								<property
								name=
								"managedConnectionFactory"
								ref=
								"managedConnectionFactory"
								/>
								</bean>
								<bean
								id=
								"component"
								class=
								"mypackage.MyDaoImpl"
								>
								<property
								name=
								"connectionFactory"
								ref=
								"connectionFactory"
								/>
								</bean>

In managed mode (that is, in a Java EE environment), the configuration could look as follows:

								<jee:jndi-lookup
								id=
								"connectionFactory"
								jndi-name=
								"eis/cicseci"
								/>
								<bean
								id=
								"component"
								class=
								"MyDaoImpl"
								>
								<property
								name=
								"connectionFactory"
								ref=
								"connectionFactory"
								/>
								</bean>

32.4 Modeling CCI access as operation objects

The org.springframework.jca.cci.objectpackage contains support classes that allow you to access the EIS in a different style: through reusable operation objects, analogous to Spring’s JDBC operation objects (see JDBC chapter). This will usually encapsulate the CCI API: an application-level input object will be passed to the operation object, so it can construct the input record and then convert the received record data to an application-level output object and return it.

[Note] Note

This approach is internally based on the CciTemplateclass and the RecordCreator/ RecordExtractorinterfaces, reusing the machinery of Spring’s core CCI support.

32.4.1 MappingRecordOperation

MappingRecordOperationessentially performs the same work as CciTemplate, but represents a specific, pre-configured operation as an object. It provides two template methods to specify how to convert an input object to a input record, and how to convert an output record to an output object (record mapping):

  • createInputRecord(..)to specify how to convert an input object to an input Record
  • extractOutputData(..)to specify how to extract an output object from an output Record

Here are the signatures of these methods:

								public
								abstract
								classMappingRecordOperation
								extendsEisOperation { ...
								protected
								abstractRecord createInputRecord(RecordFactory recordFactory, Object inputObject)
								throwsResourceException, DataAccessException {
								// ...}
								protected
								abstractObject extractOutputData(Record outputRecord)
								throwsResourceException, SQLException, DataAccessException {
								// ...} ... }

Thereafter, in order to execute an EIS operation, you need to use a single execute method, passing in an application-level input object and receiving an application-level output object as result:

								public
								abstract
								classMappingRecordOperation
								extendsEisOperation { ...
								publicObject execute(Object inputObject)
								throwsDataAccessException { } ... }

As you can see, contrary to the CciTemplateclass, this execute(..)method does not have an InteractionSpecas argument. Instead, the InteractionSpecis global to the operation. The following constructor must be used to instantiate an operation object with a specific InteractionSpec:

InteractionSpec spec = ...; MyMappingRecordOperation eisOperation =
								newMyMappingRecordOperation(getConnectionFactory(), spec); ...

32.4.2 MappingCommAreaOperation

Some connectors use records based on a COMMAREA which represents an array of bytes containing parameters to send to the EIS and data returned by it. Spring provides a special operation class for working directly on COMMAREA rather than on records. The MappingCommAreaOperationclass extends the MappingRecordOperationclass to provide such special COMMAREA support. It implicitly uses the CommAreaRecordclass as input and output record type, and provides two new methods to convert an input object into an input COMMAREA and the output COMMAREA into an output object.

								public
								abstract
								classMappingCommAreaOperation
								extendsMappingRecordOperation { ...
								protected
								abstract
								byte[] objectToBytes(Object inObject)
								throwsIOException, DataAccessException;
								protected
								abstractObject bytesToObject(
								byte[] bytes)
								throwsIOException, DataAccessException; ... }

32.4.3 Automatic output record generation

As every MappingRecordOperationsubclass is based on CciTemplate internally, the same way to automatically generate output records as with CciTemplateis available. Every operation object provides a corresponding setOutputRecordCreator(..)method. For further information, see Section 32.3.4, “Automatic output record generation”.

32.4.4 Summary

The operation object approach uses records in the same manner as the CciTemplateclass.

Table 32.2. Usage of Interaction execute methods

MappingRecordOperation method signature MappingRecordOperation outputRecordCreator property execute method called on the CCI Interaction

Object execute(Object)

not set

Record execute(InteractionSpec, Record)

Object execute(Object)

set

boolean execute(InteractionSpec, Record, Record)

32.4.5 Example for MappingRecordOperation usage

In this section, the usage of the MappingRecordOperationwill be shown to access a database with the Blackbox CCI connector.

[Note] Note

The original version of this connector is provided by the Java EE SDK (version 1.3), available from Oracle.

Firstly, some initializations on the CCI InteractionSpecmust be done to specify which SQL request to execute. In this sample, we directly define the way to convert the parameters of the request to a CCI record and the way to convert the CCI result record to an instance of the Personclass.

								public
								classPersonMappingOperation
								extendsMappingRecordOperation {
								publicPersonMappingOperation(ConnectionFactory connectionFactory) { setConnectionFactory(connectionFactory); CciInteractionSpec interactionSpec =
								newCciConnectionSpec(); interactionSpec.setSql(
								"select * from person where person_id=?"); setInteractionSpec(interactionSpec); }
								protectedRecord createInputRecord(RecordFactory recordFactory, Object inputObject)
								throwsResourceException { Integer id = (Integer) inputObject; IndexedRecord input = recordFactory.createIndexedRecord(
								"input"); input.add(
								newInteger(id));
								returninput; }
								protectedObject extractOutputData(Record outputRecord)
								throwsResourceException, SQLException { ResultSet rs = (ResultSet) outputRecord; Person person = null;
								if(rs.next()) { Person person =
								newPerson(); person.setId(rs.getInt(
								"person_id")); person.setLastName(rs.getString(
								"person_last_name")); person.setFirstName(rs.getString(
								"person_first_name")); }
								returnperson; } }

Then the application can execute the operation object, with the person identifier as argument. Note that operation object could be set up as shared instance, as it is thread-safe.

								public
								classMyDaoImpl
								extendsCciDaoSupport
								implementsMyDao {
								publicPerson getPerson(
								intid) { PersonMappingOperation query =
								newPersonMappingOperation(getConnectionFactory()); Person person = (Person) query.execute(
								newInteger(id));
								returnperson; } }

The corresponding configuration of Spring beans could look as follows in non-managed mode:

								<bean
								id=
								"managedConnectionFactory"
								class=
								"com.sun.connector.cciblackbox.CciLocalTxManagedConnectionFactory"
								>
								<property
								name=
								"connectionURL"
								value=
								"jdbc:hsqldb:hsql://localhost:9001"
								/>
								<property
								name=
								"driverName"
								value=
								"org.hsqldb.jdbcDriver"
								/>
								</bean>
								<bean
								id=
								"targetConnectionFactory"
								class=
								"org.springframework.jca.support.LocalConnectionFactoryBean"
								>
								<property
								name=
								"managedConnectionFactory"
								ref=
								"managedConnectionFactory"
								/>
								</bean>
								<bean
								id=
								"connectionFactory"
								class=
								"org.springframework.jca.cci.connection.ConnectionSpecConnectionFactoryAdapter"
								>
								<property
								name=
								"targetConnectionFactory"
								ref=
								"targetConnectionFactory"
								/>
								<property
								name=
								"connectionSpec"
								>
								<bean
								class=
								"com.sun.connector.cciblackbox.CciConnectionSpec"
								>
								<property
								name=
								"user"
								value=
								"sa"
								/>
								<property
								name=
								"password"
								value=
								""
								/>
								</bean>
								</property>
								</bean>
								<bean
								id=
								"component"
								class=
								"MyDaoImpl"
								>
								<property
								name=
								"connectionFactory"
								ref=
								"connectionFactory"
								/>
								</bean>

In managed mode (that is, in a Java EE environment), the configuration could look as follows:

								<jee:jndi-lookup
								id=
								"targetConnectionFactory"
								jndi-name=
								"eis/blackbox"
								/>
								<bean
								id=
								"connectionFactory"
								class=
								"org.springframework.jca.cci.connection.ConnectionSpecConnectionFactoryAdapter"
								>
								<property
								name=
								"targetConnectionFactory"
								ref=
								"targetConnectionFactory"
								/>
								<property
								name=
								"connectionSpec"
								>
								<bean
								class=
								"com.sun.connector.cciblackbox.CciConnectionSpec"
								>
								<property
								name=
								"user"
								value=
								"sa"
								/>
								<property
								name=
								"password"
								value=
								""
								/>
								</bean>
								</property>
								</bean>
								<bean
								id=
								"component"
								class=
								"MyDaoImpl"
								>
								<property
								name=
								"connectionFactory"
								ref=
								"connectionFactory"
								/>
								</bean>

32.4.6 Example for MappingCommAreaOperation usage

In this section, the usage of the MappingCommAreaOperationwill be shown: accessing a CICS with ECI mode with the IBM CICS ECI connector.

Firstly, the CCI InteractionSpecneeds to be initialized to specify which CICS program to access and how to interact with it.

								public
								abstract
								classEciMappingOperation
								extendsMappingCommAreaOperation {
								publicEciMappingOperation(ConnectionFactory connectionFactory, String programName) { setConnectionFactory(connectionFactory); ECIInteractionSpec interactionSpec =
								newECIInteractionSpec(), interactionSpec.setFunctionName(programName); interactionSpec.setInteractionVerb(ECIInteractionSpec.SYNC_SEND_RECEIVE); interactionSpec.setCommareaLength(
								30); setInteractionSpec(interactionSpec); setOutputRecordCreator(
								newEciOutputRecordCreator()); }
								private
								static
								classEciOutputRecordCreator
								implementsRecordCreator {
								publicRecord createRecord(RecordFactory recordFactory)
								throwsResourceException {
								return
								newCommAreaRecord(); } } }

The abstract EciMappingOperationclass can then be subclassed to specify mappings between custom objects and Records.

								public
								classMyDaoImpl
								extendsCciDaoSupport
								implementsMyDao {
								publicOutputObject getData(Integer id) { EciMappingOperation query =
								newEciMappingOperation(getConnectionFactory(),
								"MYPROG") {
								protected
								abstract
								byte[] objectToBytes(Object inObject)
								throwsIOException { Integer id = (Integer) inObject;
								returnString.valueOf(id); }
								protected
								abstractObject bytesToObject(
								byte[] bytes)
								throwsIOException; String str =
								newString(bytes); String field1 = str.substring(
								0,
								6); String field2 = str.substring(
								6,
								1); String field3 = str.substring(
								7,
								1);
								return
								newOutputObject(field1, field2, field3); } });
								return(OutputObject) query.execute(
								newInteger(id)); } }

The corresponding configuration of Spring beans could look as follows in non-managed mode:

								<bean
								id=
								"managedConnectionFactory"
								class=
								"com.ibm.connector2.cics.ECIManagedConnectionFactory"
								>
								<property
								name=
								"serverName"
								value=
								"TXSERIES"
								/>
								<property
								name=
								"connectionURL"
								value=
								"local:"
								/>
								<property
								name=
								"userName"
								value=
								"CICSUSER"
								/>
								<property
								name=
								"password"
								value=
								"CICS"
								/>
								</bean>
								<bean
								id=
								"connectionFactory"
								class=
								"org.springframework.jca.support.LocalConnectionFactoryBean"
								>
								<property
								name=
								"managedConnectionFactory"
								ref=
								"managedConnectionFactory"
								/>
								</bean>
								<bean
								id=
								"component"
								class=
								"MyDaoImpl"
								>
								<property
								name=
								"connectionFactory"
								ref=
								"connectionFactory"
								/>
								</bean>

In managed mode (that is, in a Java EE environment), the configuration could look as follows:

								<jee:jndi-lookup
								id=
								"connectionFactory"
								jndi-name=
								"eis/cicseci"
								/>
								<bean
								id=
								"component"
								class=
								"MyDaoImpl"
								>
								<property
								name=
								"connectionFactory"
								ref=
								"connectionFactory"
								/>
								</bean>

32.5 Transactions

JCA specifies several levels of transaction support for resource adapters. The kind of transactions that your resource adapter supports is specified in its ra.xmlfile. There are essentially three options: none (for example with CICS EPI connector), local transactions (for example with a CICS ECI connector), global transactions (for example with an IMS connector).

							<connector>
							<resourceadapter>
							<!-- <transaction-support>NoTransaction</transaction-support> -->
							<!-- <transaction-support>LocalTransaction</transaction-support> -->
							<transaction-support>XATransaction
							</transaction-support>
							<resourceadapter>
							<connector>

For global transactions, you can use Spring’s generic transaction infrastructure to demarcate transactions, with JtaTransactionManageras backend (delegating to the Java EE server’s distributed transaction coordinator underneath).

For local transactions on a single CCI ConnectionFactory, Spring provides a specific transaction management strategy for CCI, analogous to the DataSourceTransactionManagerfor JDBC. The CCI API defines a local transaction object and corresponding local transaction demarcation methods. Spring’s CciLocalTransactionManagerexecutes such local CCI transactions, fully compliant with Spring’s generic PlatformTransactionManagerabstraction.

							<jee:jndi-lookup
							id=
							"eciConnectionFactory"
							jndi-name=
							"eis/cicseci"
							/>
							<bean
							id=
							"eciTransactionManager"
							class=
							"org.springframework.jca.cci.connection.CciLocalTransactionManager"
							>
							<property
							name=
							"connectionFactory"
							ref=
							"eciConnectionFactory"
							/>
							</bean>

Both transaction strategies can be used with any of Spring’s transaction demarcation facilities, be it declarative or programmatic. This is a consequence of Spring’s generic PlatformTransactionManagerabstraction, which decouples transaction demarcation from the actual execution strategy. Simply switch between JtaTransactionManagerand CciLocalTransactionManageras needed, keeping your transaction demarcation as-is.

For more information on Spring’s transaction facilities, see the chapter entitled Chapter 17, Transaction Management .

33. Email

33.1 Introduction

Library dependencies

The following JAR needs to be on the classpath of your application in order to use the Spring Framework’s email library.

This library is freely available on the web — for example, in Maven Central as com.sun.mail:javax.mail.

The Spring Framework provides a helpful utility library for sending email that shields the user from the specifics of the underlying mailing system and is responsible for low level resource handling on behalf of the client.

The org.springframework.mailpackage is the root level package for the Spring Framework’s email support. The central interface for sending emails is the MailSenderinterface; a simple value object encapsulating the properties of a simple mail such as fromand to(plus many others) is the SimpleMailMessageclass. This package also contains a hierarchy of checked exceptions which provide a higher level of abstraction over the lower level mail system exceptions with the root exception being MailException. Please refer to the javadocs for more information on the rich mail exception hierarchy.

The org.springframework.mail.javamail.JavaMailSenderinterface adds specialized JavaMailfeatures such as MIME message support to the MailSenderinterface (from which it inherits). JavaMailSenderalso provides a callback interface for preparation of JavaMail MIME messages, called org.springframework.mail.javamail.MimeMessagePreparator

33.2 Usage

Let’s assume there is a business interface called OrderManager:

							public
							interfaceOrderManager {
							voidplaceOrder(Order order); }

Let us also assume that there is a requirement stating that an email message with an order number needs to be generated and sent to a customer placing the relevant order.

33.2.1 Basic MailSender and SimpleMailMessage usage

								importorg.springframework.mail.MailException;
								importorg.springframework.mail.MailSender;
								importorg.springframework.mail.SimpleMailMessage;
								public
								classSimpleOrderManager
								implementsOrderManager {
								privateMailSender mailSender;
								privateSimpleMailMessage templateMessage;
								public
								voidsetMailSender(MailSender mailSender) {
								this.mailSender = mailSender; }
								public
								voidsetTemplateMessage(SimpleMailMessage templateMessage) {
								this.templateMessage = templateMessage; }
								public
								voidplaceOrder(Order order) {
								// Do the business calculations...
								// Call the collaborators to persist the order...
								// Create a thread safe "copy" of the template message and customize itSimpleMailMessage msg =
								newSimpleMailMessage(
								this.templateMessage); msg.setTo(order.getCustomer().getEmailAddress()); msg.setText(
								"Dear "+ order.getCustomer().getFirstName() + order.getCustomer().getLastName() +
								", thank you for placing order. Your order number is "+ order.getOrderNumber());
								try{
								this.mailSender.send(msg); }
								catch(MailException ex) {
								// simply log it and go on...System.err.println(ex.getMessage()); } } }

Find below the bean definitions for the above code:

								<bean
								id=
								"mailSender"
								class=
								"org.springframework.mail.javamail.JavaMailSenderImpl"
								>
								<property
								name=
								"host"
								value=
								"mail.mycompany.com"
								/>
								</bean>
								<!-- this is a template message that we can pre-load with default state -->
								<bean
								id=
								"templateMessage"
								class=
								"org.springframework.mail.SimpleMailMessage"
								>
								<property
								name=
								"from"
								value=
								"customerservice@mycompany.com"
								/>
								<property
								name=
								"subject"
								value=
								"Your order"
								/>
								</bean>
								<bean
								id=
								"orderManager"
								class=
								"com.mycompany.businessapp.support.SimpleOrderManager"
								>
								<property
								name=
								"mailSender"
								ref=
								"mailSender"
								/>
								<property
								name=
								"templateMessage"
								ref=
								"templateMessage"
								/>
								</bean>

33.2.2 Using the JavaMailSender and the MimeMessagePreparator

Here is another implementation of OrderManagerusing the MimeMessagePreparatorcallback interface. Please note in this case that the mailSenderproperty is of type JavaMailSenderso that we are able to use the JavaMail MimeMessageclass:

								importjavax.mail.Message;
								importjavax.mail.MessagingException;
								importjavax.mail.internet.InternetAddress;
								importjavax.mail.internet.MimeMessage;
								importjavax.mail.internet.MimeMessage;
								importorg.springframework.mail.MailException;
								importorg.springframework.mail.javamail.JavaMailSender;
								importorg.springframework.mail.javamail.MimeMessagePreparator;
								public
								classSimpleOrderManager
								implementsOrderManager {
								privateJavaMailSender mailSender;
								public
								voidsetMailSender(JavaMailSender mailSender) {
								this.mailSender = mailSender; }
								public
								voidplaceOrder(
								finalOrder order) {
								// Do the business calculations...
								// Call the collaborators to persist the order...MimeMessagePreparator preparator =
								newMimeMessagePreparator() {
								public
								voidprepare(MimeMessage mimeMessage)
								throwsException { mimeMessage.setRecipient(Message.RecipientType.TO,
								newInternetAddress(order.getCustomer().getEmailAddress())); mimeMessage.setFrom(
								newInternetAddress(
								"mail@mycompany.com")); mimeMessage.setText(
								"Dear "+ order.getCustomer().getFirstName() +
								" "+ order.getCustomer().getLastName() +
								", thank you for placing order. Your order number is "+ order.getOrderNumber()); } };
								try{
								this.mailSender.send(preparator); }
								catch(MailException ex) {
								// simply log it and go on...System.err.println(ex.getMessage()); } } }
[Note] Note

The mail code is a crosscutting concern and could well be a candidate for refactoring into a custom Spring AOP aspect, which then could be executed at appropriate joinpoints on the OrderManagertarget.

The Spring Framework’s mail support ships with the standard JavaMail implementation. Please refer to the relevant javadocs for more information.

33.3 Using the JavaMail MimeMessageHelper

A class that comes in pretty handy when dealing with JavaMail messages is the org.springframework.mail.javamail.MimeMessageHelperclass, which shields you from having to use the verbose JavaMail API. Using the MimeMessageHelperit is pretty easy to create a MimeMessage:

							// of course you would use DI in any real-world casesJavaMailSenderImpl sender =
							newJavaMailSenderImpl(); sender.setHost(
							"mail.host.com"); MimeMessage message = sender.createMimeMessage(); MimeMessageHelper helper =
							newMimeMessageHelper(message); helper.setTo(
							"test@host.com"); helper.setText(
							"Thank you for ordering!"); sender.send(message);

33.3.1 Sending attachments and inline resources

Multipart email messages allow for both attachments and inline resources. Examples of inline resources would be images or a stylesheet you want to use in your message, but that you don’t want displayed as an attachment.

Attachments

The following example shows you how to use the MimeMessageHelperto send an email along with a single JPEG image attachment.

JavaMailSenderImpl sender =
									newJavaMailSenderImpl(); sender.setHost(
									"mail.host.com"); MimeMessage message = sender.createMimeMessage();
									// use the true flag to indicate you need a multipart messageMimeMessageHelper helper =
									newMimeMessageHelper(message, true); helper.setTo(
									"test@host.com"); helper.setText(
									"Check out this image!");
									// let's attach the infamous windows Sample file (this time copied to c:/)FileSystemResource file =
									newFileSystemResource(
									newFile(
									"c:/Sample.jpg")); helper.addAttachment(
									"CoolImage.jpg", file); sender.send(message);

Inline resources

The following example shows you how to use the MimeMessageHelperto send an email along with an inline image.

JavaMailSenderImpl sender =
									newJavaMailSenderImpl(); sender.setHost(
									"mail.host.com"); MimeMessage message = sender.createMimeMessage();
									// use the true flag to indicate you need a multipart messageMimeMessageHelper helper =
									newMimeMessageHelper(message, true); helper.setTo(
									"test@host.com");
									// use the true flag to indicate the text included is HTMLhelper.setText(
									"<html><body><img src='cid:identifier1234'></body></html>", true);
									// let's include the infamous windows Sample file (this time copied to c:/)FileSystemResource res =
									newFileSystemResource(
									newFile(
									"c:/Sample.jpg")); helper.addInline(
									"identifier1234", res); sender.send(message);
[Warning] Warning

Inline resources are added to the mime message using the specified Content-ID( identifier1234in the above example). The order in which you are adding the text and the resource are veryimportant. Be sure to first add the textand after that the resources. If you are doing it the other way around, it won’t work!

33.3.2 Creating email content using a templating library

The code in the previous examples explicitly created the content of the email message, using methods calls such as message.setText(..). This is fine for simple cases, and it is okay in the context of the aforementioned examples, where the intent was to show you the very basics of the API.

In your typical enterprise application though, you are not going to create the content of your emails using the above approach for a number of reasons.

  • Creating HTML-based email content in Java code is tedious and error prone
  • There is no clear separation between display logic and business logic
  • Changing the display structure of the email content requires writing Java code, recompiling, redeploying…​

Typically the approach taken to address these issues is to use a template library such as FreeMarker or Velocity to define the display structure of email content. This leaves your code tasked only with creating the data that is to be rendered in the email template and sending the email. It is definitely a best practice for when the content of your emails becomes even moderately complex, and with the Spring Framework’s support classes for FreeMarker and Velocity becomes quite easy to do. Find below an example of using the Velocity template library to create email content.

A Velocity-based example

To use Velocityto create your email template(s), you will need to have the Velocity libraries available on your classpath. You will also need to create one or more Velocity templates for the email content that your application needs. Find below the Velocity template that this example will be using. As you can see it is HTML-based, and since it is plain text it can be created using your favorite HTML or text editor.

# in the com/foo/package
									<html>
									<body>
									<h3>Hi ${user.userName}, welcome to the Chipping Sodbury On-the-Hill message boards!
									</h3>
									<div>Your email address is
									<a
									href=
									"mailto:${user.emailAddress}"
									>${user.emailAddress}
									</a>.
									</div>
									</body>
									</html>

Find below some simple code and Spring XML configuration that makes use of the above Velocity template to create email content and send email(s).

									packagecom.foo;
									importorg.apache.velocity.app.VelocityEngine;
									importorg.springframework.mail.javamail.JavaMailSender;
									importorg.springframework.mail.javamail.MimeMessageHelper;
									importorg.springframework.mail.javamail.MimeMessagePreparator;
									importorg.springframework.ui.velocity.VelocityEngineUtils;
									importjavax.mail.internet.MimeMessage;
									importjava.util.HashMap;
									importjava.util.Map;
									public
									classSimpleRegistrationService
									implementsRegistrationService {
									privateJavaMailSender mailSender;
									privateVelocityEngine velocityEngine;
									public
									voidsetMailSender(JavaMailSender mailSender) {
									this.mailSender = mailSender; }
									public
									voidsetVelocityEngine(VelocityEngine velocityEngine) {
									this.velocityEngine = velocityEngine; }
									public
									voidregister(User user) {
									// Do the registration logic...sendConfirmationEmail(user); }
									private
									voidsendConfirmationEmail(
									finalUser user) { MimeMessagePreparator preparator =
									newMimeMessagePreparator() {
									public
									voidprepare(MimeMessage mimeMessage)
									throwsException { MimeMessageHelper message =
									newMimeMessageHelper(mimeMessage); message.setTo(user.getEmailAddress()); message.setFrom(
									"webmaster@csonth.gov.uk");
									// could be parameterized...Map model =
									newHashMap(); model.put(
									"user", user); String text = VelocityEngineUtils.mergeTemplateIntoString( velocityEngine,
									"com/dns/registration-confirmation.vm", model); message.setText(text, true); } };
									this.mailSender.send(preparator); } }
									<?xml version="1.0" encoding="UTF-8"?>
									<beans
									xmlns=
									"http://www.springframework.org/schema/beans"
									xmlns:xsi=
									"http://www.w3.org/2001/XMLSchema-instance"
									xsi:schemaLocation=
									"http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd"
									>
									<bean
									id=
									"mailSender"
									class=
									"org.springframework.mail.javamail.JavaMailSenderImpl"
									>
									<property
									name=
									"host"
									value=
									"mail.csonth.gov.uk"
									/>
									</bean>
									<bean
									id=
									"registrationService"
									class=
									"com.foo.SimpleRegistrationService"
									>
									<property
									name=
									"mailSender"
									ref=
									"mailSender"
									/>
									<property
									name=
									"velocityEngine"
									ref=
									"velocityEngine"
									/>
									</bean>
									<bean
									id=
									"velocityEngine"
									class=
									"org.springframework.ui.velocity.VelocityEngineFactoryBean"
									>
									<property
									name=
									"velocityProperties"
									>
									<value>resource.loader=class class.resource.loader.class=org.apache.velocity.runtime.resource.loader.ClasspathResourceLoader
									</value>
									</property>
									</bean>
									</beans>

34. Task Execution and Scheduling

34.1 Introduction

The Spring Framework provides abstractions for asynchronous execution and scheduling of tasks with the TaskExecutorand TaskSchedulerinterfaces, respectively. Spring also features implementations of those interfaces that support thread pools or delegation to CommonJ within an application server environment. Ultimately the use of these implementations behind the common interfaces abstracts away the differences between Java SE 5, Java SE 6 and Java EE environments.

Spring also features integration classes for supporting scheduling with the Timer, part of the JDK since 1.3, and the Quartz Scheduler ( http://quartz-scheduler.org). Both of those schedulers are set up using a FactoryBeanwith optional references to Timeror Triggerinstances, respectively. Furthermore, a convenience class for both the Quartz Scheduler and the Timeris available that allows you to invoke a method of an existing target object (analogous to the normal MethodInvokingFactoryBeanoperation).

34.2 The Spring TaskExecutor abstraction

Spring 2.0 introduces a new abstraction for dealing with executors. Executors are the Java 5 name for the concept of thread pools. The "executor" naming is due to the fact that there is no guarantee that the underlying implementation is actually a pool; an executor may be single-threaded or even synchronous. Spring’s abstraction hides implementation details between Java SE 1.4, Java SE 5 and Java EE environments.

Spring’s TaskExecutorinterface is identical to the java.util.concurrent.Executorinterface. In fact, its primary reason for existence was to abstract away the need for Java 5 when using thread pools. The interface has a single method execute(Runnable task)that accepts a task for execution based on the semantics and configuration of the thread pool.

The TaskExecutorwas originally created to give other Spring components an abstraction for thread pooling where needed. Components such as the ApplicationEventMulticaster, JMS’s AbstractMessageListenerContainer, and Quartz integration all use the TaskExecutorabstraction to pool threads. However, if your beans need thread pooling behavior, it is possible to use this abstraction for your own needs.

34.2.1 TaskExecutor types

There are a number of pre-built implementations of TaskExecutorincluded with the Spring distribution. In all likelihood, you shouldn’t ever need to implement your own.

  • SimpleAsyncTaskExecutorThis implementation does not reuse any threads, rather it starts up a new thread for each invocation. However, it does support a concurrency limit which will block any invocations that are over the limit until a slot has been freed up. If you are looking for true pooling, see the discussions of SimpleThreadPoolTaskExecutorand ThreadPoolTaskExecutorbelow.
  • SyncTaskExecutorThis implementation doesn’t execute invocations asynchronously. Instead, each invocation takes place in the calling thread. It is primarily used in situations where multi-threading isn’t necessary such as simple test cases.
  • ConcurrentTaskExecutorThis implementation is an adapter for a java.util.concurrent.Executorobject. There is an alternative, ThreadPoolTaskExecutor, that exposes the Executorconfiguration parameters as bean properties. It is rare to need to use the ConcurrentTaskExecutor, but if the ThreadPoolTaskExecutorisn’t flexible enough for your needs, the ConcurrentTaskExecutoris an alternative.
  • SimpleThreadPoolTaskExecutorThis implementation is actually a subclass of Quartz’s SimpleThreadPoolwhich listens to Spring’s lifecycle callbacks. This is typically used when you have a thread pool that may need to be shared by both Quartz and non-Quartz components.
  • ThreadPoolTaskExecutorThis implementation is the most commonly used one. It exposes bean properties for configuring a java.util.concurrent.ThreadPoolExecutorand wraps it in a TaskExecutor. If you need to adapt to a different kind of java.util.concurrent.Executor, it is recommended that you use a ConcurrentTaskExecutorinstead.

  • WorkManagerTaskExecutor

    CommonJ is a set of specifications jointly developed between BEA and IBM. These specifications are not Java EE standards, but are standard across BEA’s and IBM’s Application Server implementations.

    This implementation uses the CommonJ WorkManageras its backing implementation and is the central convenience class for setting up a CommonJ WorkManagerreference in a Spring context. Similar to the SimpleThreadPoolTaskExecutor, this class implements the WorkManagerinterface and therefore can be used directly as a WorkManageras well.

34.2.2 Using a TaskExecutor

Spring’s TaskExecutorimplementations are used as simple JavaBeans. In the example below, we define a bean that uses the ThreadPoolTaskExecutorto asynchronously print out a set of messages.

								importorg.springframework.core.task.TaskExecutor;
								public
								classTaskExecutorExample {
								private
								classMessagePrinterTask
								implementsRunnable {
								privateString message;
								publicMessagePrinterTask(String message) {
								this.message = message; }
								public
								voidrun() { System.out.println(message); } }
								privateTaskExecutor taskExecutor;
								publicTaskExecutorExample(TaskExecutor taskExecutor) {
								this.taskExecutor = taskExecutor; }
								public
								voidprintMessages() {
								for(
								inti =
								0; i <
								25; i++) { taskExecutor.execute(
								newMessagePrinterTask(
								"Message"+ i)); } } }

As you can see, rather than retrieving a thread from the pool and executing yourself, you add your Runnableto the queue and the TaskExecutoruses its internal rules to decide when the task gets executed.

To configure the rules that the TaskExecutorwill use, simple bean properties have been exposed.

								<bean
								id=
								"taskExecutor"
								class=
								"org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor"
								>
								<property
								name=
								"corePoolSize"
								value=
								"5"
								/>
								<property
								name=
								"maxPoolSize"
								value=
								"10"
								/>
								<property
								name=
								"queueCapacity"
								value=
								"25"
								/>
								</bean>
								<bean
								id=
								"taskExecutorExample"
								class=
								"TaskExecutorExample"
								>
								<constructor-arg
								ref=
								"taskExecutor"
								/>
								</bean>

34.3 The Spring TaskScheduler abstraction

In addition to the TaskExecutorabstraction, Spring 3.0 introduces a TaskSchedulerwith a variety of methods for scheduling tasks to run at some point in the future.

							public
							interfaceTaskScheduler { ScheduledFuture schedule(Runnable task, Trigger trigger); ScheduledFuture schedule(Runnable task, Date startTime); ScheduledFuture scheduleAtFixedRate(Runnable task, Date startTime,
							longperiod); ScheduledFuture scheduleAtFixedRate(Runnable task,
							longperiod); ScheduledFuture scheduleWithFixedDelay(Runnable task, Date startTime,
							longdelay); ScheduledFuture scheduleWithFixedDelay(Runnable task,
							longdelay); }

The simplest method is the one named 'schedule' that takes a Runnableand Dateonly. That will cause the task to run once after the specified time. All of the other methods are capable of scheduling tasks to run repeatedly. The fixed-rate and fixed-delay methods are for simple, periodic execution, but the method that accepts a Trigger is much more flexible.

34.3.1 the Trigger interface

The Triggerinterface is essentially inspired by JSR-236, which, as of Spring 3.0, has not yet been officially implemented. The basic idea of the Triggeris that execution times may be determined based on past execution outcomes or even arbitrary conditions. If these determinations do take into account the outcome of the preceding execution, that information is available within a TriggerContext. The Triggerinterface itself is quite simple:

								public
								interfaceTrigger { Date nextExecutionTime(TriggerContext triggerContext); }

As you can see, the TriggerContextis the most important part. It encapsulates all of the relevant data, and is open for extension in the future if necessary. The TriggerContextis an interface (a SimpleTriggerContextimplementation is used by default). Here you can see what methods are available for Triggerimplementations.

								public
								interfaceTriggerContext { Date lastScheduledExecutionTime(); Date lastActualExecutionTime(); Date lastCompletionTime(); }

34.3.2 Trigger implementations

Spring provides two implementations of the Triggerinterface. The most interesting one is the CronTrigger. It enables the scheduling of tasks based on cron expressions. For example, the following task is being scheduled to run 15 minutes past each hour but only during the 9-to-5 "business hours" on weekdays.

scheduler.schedule(task,
								newCronTrigger(
								"0 15 9-17 * * MON-FRI"));

The other out-of-the-box implementation is a PeriodicTriggerthat accepts a fixed period, an optional initial delay value, and a boolean to indicate whether the period should be interpreted as a fixed-rate or a fixed-delay. Since the TaskSchedulerinterface already defines methods for scheduling tasks at a fixed-rate or with a fixed-delay, those methods should be used directly whenever possible. The value of the PeriodicTriggerimplementation is that it can be used within components that rely on the Triggerabstraction. For example, it may be convenient to allow periodic triggers, cron-based triggers, and even custom trigger implementations to be used interchangeably. Such a component could take advantage of dependency injection so that such Triggerscould be configured externally and therefore easily modified or extended.

34.3.3 TaskScheduler implementations

As with Spring’s TaskExecutorabstraction, the primary benefit of the TaskScheduleris that code relying on scheduling behavior need not be coupled to a particular scheduler implementation. The flexibility this provides is particularly relevant when running within Application Server environments where threads should not be created directly by the application itself. For such cases, Spring provides a TimerManagerTaskSchedulerthat delegates to a CommonJ TimerManager instance, typically configured with a JNDI-lookup.

A simpler alternative, the ThreadPoolTaskScheduler, can be used whenever external thread management is not a requirement. Internally, it delegates to a ScheduledExecutorServiceinstance. ThreadPoolTaskScheduleractually implements Spring’s TaskExecutorinterface as well, so that a single instance can be used for asynchronous execution as soon as possibleas well as scheduled, and potentially recurring, executions.

34.4 Annotation Support for Scheduling and Asynchronous Execution

Spring provides annotation support for both task scheduling and asynchronous method execution.

34.4.1 Enable scheduling annotations

To enable support for @Scheduledand @Asyncannotations add @EnableSchedulingand @EnableAsyncto one of your @Configurationclasses:

								
									@Configuration
								
									@EnableAsync
								
									@EnableScheduling
								public
								classAppConfig { }

You are free to pick and choose the relevant annotations for your application. For example, if you only need support for @Scheduled, simply omit @EnableAsync. For more fine-grained control you can additionally implement the SchedulingConfigurerand/or AsyncConfigurerinterfaces. See the javadocs for full details.

If you prefer XML configuration use the <task:annotation-driven>element.

								<task:annotation-driven
								executor=
								"myExecutor"
								scheduler=
								"myScheduler"
								/>
								<task:executor
								id=
								"myExecutor"
								pool-size=
								"5"
								/>
								<task:scheduler
								id=
								"myScheduler"
								pool-size=
								"10"
								/>

Notice with the above XML that an executor reference is provided for handling those tasks that correspond to methods with the @Asyncannotation, and the scheduler reference is provided for managing those methods annotated with @Scheduled.

34.4.2 The @Scheduled annotation

The @Scheduledannotation can be added to a method along with trigger metadata. For example, the following method would be invoked every 5 seconds with a fixed delay, meaning that the period will be measured from the completion time of each preceding invocation.

								
									@Scheduled(fixedDelay=5000)
								public
								voiddoSomething() {
								// something that should execute periodically}

If a fixed rate execution is desired, simply change the property name specified within the annotation. The following would be executed every 5 seconds measured between the successive start times of each invocation.

								
									@Scheduled(fixedRate=5000)
								public
								voiddoSomething() {
								// something that should execute periodically}

For fixed-delay and fixed-rate tasks, an initial delay may be specified indicating the number of milliseconds to wait before the first execution of the method.

								
									@Scheduled(initialDelay=1000, fixedRate=5000)
								public
								voiddoSomething() {
								// something that should execute periodically}

If simple periodic scheduling is not expressive enough, then a cron expression may be provided. For example, the following will only execute on weekdays.

								
									@Scheduled(cron="*/5 * * * * MON-FRI")
								public
								voiddoSomething() {
								// something that should execute on weekdays only}
[Tip] Tip

You can additionally use the zoneattribute to specify the time zone in which the cron expression will be resolved.

Notice that the methods to be scheduled must have void returns and must not expect any arguments. If the method needs to interact with other objects from the Application Context, then those would typically have been provided through dependency injection.

[Note] Note

As of Spring Framework 4.3, @Scheduledmethods are supported on beans of any scope.

Make sure that you are not initializing multiple instances of the same @Scheduledannotation class at runtime, unless you do want to schedule callbacks to each such instance. Related to this, make sure that you do not use @Configurableon bean classes which are annotated with @Scheduledand registered as regular Spring beans with the container: You would get double initialization otherwise, once through the container and once through the @Configurableaspect, with the consequence of each @Scheduledmethod being invoked twice.

34.4.3 The @Async annotation

The @Asyncannotation can be provided on a method so that invocation of that method will occur asynchronously. In other words, the caller will return immediately upon invocation and the actual execution of the method will occur in a task that has been submitted to a Spring TaskExecutor. In the simplest case, the annotation may be applied to a void-returning method.

								
									@Async
								voiddoSomething() {
								// this will be executed asynchronously}

Unlike the methods annotated with the @Scheduledannotation, these methods can expect arguments, because they will be invoked in the "normal" way by callers at runtime rather than from a scheduled task being managed by the container. For example, the following is a legitimate application of the @Asyncannotation.

								
									@Async
								voiddoSomething(String s) {
								// this will be executed asynchronously}

Even methods that return a value can be invoked asynchronously. However, such methods are required to have a Futuretyped return value. This still provides the benefit of asynchronous execution so that the caller can perform other tasks prior to calling get()on that Future.

								
									@AsyncFuture<String> returnSomething(
								inti) {
								// this will be executed asynchronously}
[Tip] Tip

@Asyncmethods may not only declare a regular java.util.concurrent.Futurereturn type but also Spring’s org.springframework.util.concurrent.ListenableFutureor, as of Spring 4.2, JDK 8’s java.util.concurrent.CompletableFuture: for richer interaction with the asynchronous task and for immediate composition with further processing steps.

@Asynccan not be used in conjunction with lifecycle callbacks such as @PostConstruct. To asynchronously initialize Spring beans you currently have to use a separate initializing Spring bean that invokes the @Asyncannotated method on the target then.

								public
								classSampleBeanImpl
								implementsSampleBean {
								
									@Async
								voiddoSomething() {
								// ...} }
								public
								classSampleBeanInitializer {
								private
								finalSampleBean bean;
								publicSampleBeanInitializer(SampleBean bean) {
								this.bean = bean; }
								
									@PostConstruct
								public
								voidinitialize() { bean.doSomething(); } }
[Note] Note

There is no direct XML equivalent for @Asyncsince such methods should be designed for asynchronous execution in the first place, not externally re-declared to be async. However, you may manually set up Spring’s AsyncExecutionInterceptorwith Spring AOP, in combination with a custom pointcut.

34.4.4 Executor qualification with @Async

By default when specifying @Asyncon a method, the executor that will be used is the one supplied to the 'annotation-driven' element as described above. However, the valueattribute of the @Asyncannotation can be used when needing to indicate that an executor other than the default should be used when executing a given method.

								
									@Async("otherExecutor")
								voiddoSomething(String s) {
								// this will be executed asynchronously by "otherExecutor"}

In this case, "otherExecutor" may be the name of any Executorbean in the Spring container, or may be the name of a qualifierassociated with any Executor, e.g. as specified with the <qualifier>element or Spring’s @Qualifierannotation.

34.4.5 Exception management with @Async

When an @Asyncmethod has a Futuretyped return value, it is easy to manage an exception that was thrown during the method execution as this exception will be thrown when calling geton the Futureresult. With a void return type however, the exception is uncaught and cannot be transmitted. For those cases, an AsyncUncaughtExceptionHandlercan be provided to handle such exceptions.

								public
								classMyAsyncUncaughtExceptionHandler
								implementsAsyncUncaughtExceptionHandler {
								
									@Override
								public
								voidhandleUncaughtException(Throwable ex, Method method, Object... params) {
								// handle exception} }

By default, the exception is simply logged. A custom AsyncUncaughtExceptionHandlercan be defined via AsyncConfigureror the task:annotation-drivenXML element.

34.5 The task namespace

Beginning with Spring 3.0, there is an XML namespace for configuring TaskExecutorand TaskSchedulerinstances. It also provides a convenient way to configure tasks to be scheduled with a trigger.

34.5.1 The 'scheduler' element

The following element will create a ThreadPoolTaskSchedulerinstance with the specified thread pool size.

								<task:scheduler
								id=
								"scheduler"
								pool-size=
								"10"
								/>

The value provided for the 'id' attribute will be used as the prefix for thread names within the pool. The 'scheduler' element is relatively straightforward. If you do not provide a 'pool-size' attribute, the default thread pool will only have a single thread. There are no other configuration options for the scheduler.

34.5.2 The 'executor' element

The following will create a ThreadPoolTaskExecutorinstance:

								<task:executor
								id=
								"executor"
								pool-size=
								"10"
								/>

As with the scheduler above, the value provided for the 'id' attribute will be used as the prefix for thread names within the pool. As far as the pool size is concerned, the 'executor' element supports more configuration options than the 'scheduler' element. For one thing, the thread pool for a ThreadPoolTaskExecutoris itself more configurable. Rather than just a single size, an executor’s thread pool may have different values for the coreand the maxsize. If a single value is provided then the executor will have a fixed-size thread pool (the core and max sizes are the same). However, the 'executor' element’s 'pool-size' attribute also accepts a range in the form of "min-max".

								<task:executor
								id=
								"executorWithPoolSizeRange"
								pool-size=
								"5-25"
								queue-capacity=
								"100"
								/>

As you can see from that configuration, a 'queue-capacity' value has also been provided. The configuration of the thread pool should also be considered in light of the executor’s queue capacity. For the full description of the relationship between pool size and queue capacity, consult the documentation for ThreadPoolExecutor. The main idea is that when a task is submitted, the executor will first try to use a free thread if the number of active threads is currently less than the core size. If the core size has been reached, then the task will be added to the queue as long as its capacity has not yet been reached. Only then, if the queue’s capacity hasbeen reached, will the executor create a new thread beyond the core size. If the max size has also been reached, then the executor will reject the task.

By default, the queue is unbounded, but this is rarely the desired configuration, because it can lead to OutOfMemoryErrorsif enough tasks are added to that queue while all pool threads are busy. Furthermore, if the queue is unbounded, then the max size has no effect at all. Since the executor will always try the queue before creating a new thread beyond the core size, a queue must have a finite capacity for the thread pool to grow beyond the core size (this is why a fixed sizepool is the only sensible case when using an unbounded queue).

In a moment, we will review the effects of the keep-alive setting which adds yet another factor to consider when providing a pool size configuration. First, let’s consider the case, as mentioned above, when a task is rejected. By default, when a task is rejected, a thread pool executor will throw a TaskRejectedException. However, the rejection policy is actually configurable. The exception is thrown when using the default rejection policy which is the AbortPolicyimplementation. For applications where some tasks can be skipped under heavy load, either the DiscardPolicyor DiscardOldestPolicymay be configured instead. Another option that works well for applications that need to throttle the submitted tasks under heavy load is the CallerRunsPolicy. Instead of throwing an exception or discarding tasks, that policy will simply force the thread that is calling the submit method to run the task itself. The idea is that such a caller will be busy while running that task and not able to submit other tasks immediately. Therefore it provides a simple way to throttle the incoming load while maintaining the limits of the thread pool and queue. Typically this allows the executor to "catch up" on the tasks it is handling and thereby frees up some capacity on the queue, in the pool, or both. Any of these options can be chosen from an enumeration of values available for the 'rejection-policy' attribute on the 'executor' element.

								<task:executor
								id=
								"executorWithCallerRunsPolicy"
								pool-size=
								"5-25"
								queue-capacity=
								"100"
								rejection-policy=
								"CALLER_RUNS"
								/>

Finally, the keep-alivesetting determines the time limit (in seconds) for which threads may remain idle before being terminated. If there are more than the core number of threads currently in the pool, after waiting this amount of time without processing a task, excess threads will get terminated. A time value of zero will cause excess threads to terminate immediately after executing a task without remaining follow-up work in the task queue.

								<task:executor
								id=
								"executorWithKeepAlive"
								pool-size=
								"5-25"
								keep-alive=
								"120"
								/>

34.5.3 The 'scheduled-tasks' element

The most powerful feature of Spring’s task namespace is the support for configuring tasks to be scheduled within a Spring Application Context. This follows an approach similar to other "method-invokers" in Spring, such as that provided by the JMS namespace for configuring Message-driven POJOs. Basically a "ref" attribute can point to any Spring-managed object, and the "method" attribute provides the name of a method to be invoked on that object. Here is a simple example.

								<task:scheduled-tasks
								scheduler=
								"myScheduler"
								>
								<task:scheduled
								ref=
								"beanA"
								method=
								"methodA"
								fixed-delay=
								"5000"
								/>
								</task:scheduled-tasks>
								<task:scheduler
								id=
								"myScheduler"
								pool-size=
								"10"
								/>

As you can see, the scheduler is referenced by the outer element, and each individual task includes the configuration of its trigger metadata. In the preceding example, that metadata defines a periodic trigger with a fixed delay indicating the number of milliseconds to wait after each task execution has completed. Another option is 'fixed-rate', indicating how often the method should be executed regardless of how long any previous execution takes. Additionally, for both fixed-delay and fixed-rate tasks an 'initial-delay' parameter may be specified indicating the number of milliseconds to wait before the first execution of the method. For more control, a "cron" attribute may be provided instead. Here is an example demonstrating these other options.

								<task:scheduled-tasks
								scheduler=
								"myScheduler"
								>
								<task:scheduled
								ref=
								"beanA"
								method=
								"methodA"
								fixed-delay=
								"5000"
								initial-delay=
								"1000"
								/>
								<task:scheduled
								ref=
								"beanB"
								method=
								"methodB"
								fixed-rate=
								"5000"
								/>
								<task:scheduled
								ref=
								"beanC"
								method=
								"methodC"
								cron=
								"*/5 * * * * MON-FRI"
								/>
								</task:scheduled-tasks>
								<task:scheduler
								id=
								"myScheduler"
								pool-size=
								"10"
								/>

34.6 Using the Quartz Scheduler

Quartz uses Trigger, Joband JobDetailobjects to realize scheduling of all kinds of jobs. For the basic concepts behind Quartz, have a look at http://quartz-scheduler.org. For convenience purposes, Spring offers a couple of classes that simplify the usage of Quartz within Spring-based applications.

34.6.1 Using the JobDetailFactoryBean

Quartz JobDetailobjects contain all information needed to run a job. Spring provides a JobDetailFactoryBeanwhich provides bean-style properties for XML configuration purposes. Let’s have a look at an example:

								<bean
								name=
								"exampleJob"
								class=
								"org.springframework.scheduling.quartz.JobDetailFactoryBean"
								>
								<property
								name=
								"jobClass"
								value=
								"example.ExampleJob"
								/>
								<property
								name=
								"jobDataAsMap"
								>
								<map>
								<entry
								key=
								"timeout"
								value=
								"5"
								/>
								</map>
								</property>
								</bean>

The job detail configuration has all information it needs to run the job ( ExampleJob). The timeout is specified in the job data map. The job data map is available through the JobExecutionContext(passed to you at execution time), but the JobDetailalso gets its properties from the job data mapped to properties of the job instance. So in this case, if the ExampleJobcontains a bean property named timeout, the JobDetailwill have it applied automatically:

								packageexample;
								public
								classExampleJob
								extendsQuartzJobBean {
								private
								inttimeout;
								/** * Setter called after the ExampleJob is instantiated * with the value from the JobDetailFactoryBean (5) */
								public
								voidsetTimeout(
								inttimeout) {
								this.timeout = timeout; }
								protected
								voidexecuteInternal(JobExecutionContext ctx)
								throwsJobExecutionException {
								// do the actual work} }

All additional properties from the job data map are of course available to you as well.

[Note] Note

Using the nameand groupproperties, you can modify the name and the group of the job, respectively. By default, the name of the job matches the bean name of the JobDetailFactoryBean(in the example above, this is exampleJob).

34.6.2 Using the MethodInvokingJobDetailFactoryBean

Often you just need to invoke a method on a specific object. Using the MethodInvokingJobDetailFactoryBeanyou can do exactly this:

								<bean
								id=
								"jobDetail"
								class=
								"org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean"
								>
								<property
								name=
								"targetObject"
								ref=
								"exampleBusinessObject"
								/>
								<property
								name=
								"targetMethod"
								value=
								"doIt"
								/>
								</bean>

The above example will result in the doItmethod being called on the exampleBusinessObjectmethod (see below):

								public
								classExampleBusinessObject {
								// properties and collaborators
								public
								voiddoIt() {
								// do the actual work} }
								<bean
								id=
								"exampleBusinessObject"
								class=
								"examples.ExampleBusinessObject"
								/>

Using the MethodInvokingJobDetailFactoryBean, you don’t need to create one-line jobs that just invoke a method, and you only need to create the actual business object and wire up the detail object.

By default, Quartz Jobs are stateless, resulting in the possibility of jobs interfering with each other. If you specify two triggers for the same JobDetail, it might be possible that before the first job has finished, the second one will start. If JobDetailclasses implement the Statefulinterface, this won’t happen. The second job will not start before the first one has finished. To make jobs resulting from the MethodInvokingJobDetailFactoryBeannon-concurrent, set the concurrentflag to false.

								<bean
								id=
								"jobDetail"
								class=
								"org.springframework.scheduling.quartz.MethodInvokingJobDetailFactoryBean"
								>
								<property
								name=
								"targetObject"
								ref=
								"exampleBusinessObject"
								/>
								<property
								name=
								"targetMethod"
								value=
								"doIt"
								/>
								<property
								name=
								"concurrent"
								value=
								"false"
								/>
								</bean>
[Note] Note

By default, jobs will run in a concurrent fashion.

34.6.3 Wiring up jobs using triggers and the SchedulerFactoryBean

We’ve created job details and jobs. We’ve also reviewed the convenience bean that allows you to invoke a method on a specific object. Of course, we still need to schedule the jobs themselves. This is done using triggers and a SchedulerFactoryBean. Several triggers are available within Quartz and Spring offers two Quartz FactoryBeanimplementations with convenient defaults: CronTriggerFactoryBeanand SimpleTriggerFactoryBean.

Triggers need to be scheduled. Spring offers a SchedulerFactoryBeanthat exposes triggers to be set as properties. SchedulerFactoryBeanschedules the actual jobs with those triggers.

Find below a couple of examples:

								<bean
								id=
								"simpleTrigger"
								class=
								"org.springframework.scheduling.quartz.SimpleTriggerFactoryBean"
								>
								<!-- see the example of method invoking job above -->
								<property
								name=
								"jobDetail"
								ref=
								"jobDetail"
								/>
								<!-- 10 seconds -->
								<property
								name=
								"startDelay"
								value=
								"10000"
								/>
								<!-- repeat every 50 seconds -->
								<property
								name=
								"repeatInterval"
								value=
								"50000"
								/>
								</bean>
								<bean
								id=
								"cronTrigger"
								class=
								"org.springframework.scheduling.quartz.CronTriggerFactoryBean"
								>
								<property
								name=
								"jobDetail"
								ref=
								"exampleJob"
								/>
								<!-- run every morning at 6 AM -->
								<property
								name=
								"cronExpression"
								value=
								"0 0 6 * * ?"
								/>
								</bean>

Now we’ve set up two triggers, one running every 50 seconds with a starting delay of 10 seconds and one every morning at 6 AM. To finalize everything, we need to set up the SchedulerFactoryBean:

								<bean
								class=
								"org.springframework.scheduling.quartz.SchedulerFactoryBean"
								>
								<property
								name=
								"triggers"
								>
								<list>
								<ref
								bean=
								"cronTrigger"
								/>
								<ref
								bean=
								"simpleTrigger"
								/>
								</list>
								</property>
								</bean>

More properties are available for the SchedulerFactoryBeanfor you to set, such as the calendars used by the job details, properties to customize Quartz with, etc. Have a look at the SchedulerFactoryBeanjavadocsfor more information.

35. Dynamic language support

35.1 Introduction

Spring 2.0 introduces comprehensive support for using classes and objects that have been defined using a dynamic language (such as JRuby) with Spring. This support allows you to write any number of classes in a supported dynamic language, and have the Spring container transparently instantiate, configure and dependency inject the resulting objects.

The dynamic languages currently supported are:

  • JRuby 1.5+
  • Groovy 1.8+
  • BeanShell 2.0

Why only these languages?

The supported languages were chosen because a)the languages have a lot of traction in the Java enterprise community, b)no requests were made for other languages at the time that this support was added, and c)the Spring developers were most familiar with them.

Fully working examples of where this dynamic language support can be immediately useful are described in Section 35.4, “Scenarios”.

35.2 A first example

This bulk of this chapter is concerned with describing the dynamic language support in detail. Before diving into all of the ins and outs of the dynamic language support, let’s look at a quick example of a bean defined in a dynamic language. The dynamic language for this first bean is Groovy (the basis of this example was taken from the Spring test suite, so if you want to see equivalent examples in any of the other supported languages, take a look at the source code).

Find below the Messengerinterface that the Groovy bean is going to be implementing, and note that this interface is defined in plain Java. Dependent objects that are injected with a reference to the Messengerwon’t know that the underlying implementation is a Groovy script.

							packageorg.springframework.scripting;
							public
							interfaceMessenger { String getMessage(); }

Here is the definition of a class that has a dependency on the Messengerinterface.

							packageorg.springframework.scripting;
							public
							classDefaultBookingService
							implementsBookingService {
							privateMessenger messenger;
							public
							voidsetMessenger(Messenger messenger) {
							this.messenger = messenger; }
							public
							voidprocessBooking() {
							// use the injected Messenger object...} }

Here is an implementation of the Messengerinterface in Groovy.

							// from the file 'Messenger.groovy'
							packageorg.springframework.scripting.groovy;
							// import the Messenger interface (written in Java) that is to be implemented
							importorg.springframework.scripting.Messenger
							// define the implementation in Groovy
							classGroovyMessenger
							implementsMessenger { String message }

Finally, here are the bean definitions that will effect the injection of the Groovy-defined Messengerimplementation into an instance of the DefaultBookingServiceclass.

[Note] Note

To use the custom dynamic language tags to define dynamic-language-backed beans, you need to have the XML Schema preamble at the top of your Spring XML configuration file. You also need to be using a Spring ApplicationContextimplementation as your IoC container. Using the dynamic-language-backed beans with a plain BeanFactoryimplementation is supported, but you have to manage the plumbing of the Spring internals to do so.

For more information on schema-based configuration, see Chapter 41, XML Schema-based configuration .

 
							<?xml version="1.0" encoding="UTF-8"?>
							<beans
							xmlns=
							"http://www.springframework.org/schema/beans"
							xmlns:xsi=
							"http://www.w3.org/2001/XMLSchema-instance"
							xmlns:lang=
							"http://www.springframework.org/schema/lang"
							xsi:schemaLocation=
							" http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/lang http://www.springframework.org/schema/lang/spring-lang.xsd"
							>
							<!-- this is the bean definition for the Groovy-backed Messenger implementation -->
							<lang:groovy
							id=
							"messenger"
							script-source=
							"classpath:Messenger.groovy"
							>
							<lang:property
							name=
							"message"
							value=
							"I Can Do The Frug"
							/>
							</lang:groovy>
							<!-- an otherwise normal bean that will be injected by the Groovy-backed Messenger -->
							<bean
							id=
							"bookingService"
							class=
							"x.y.DefaultBookingService"
							>
							<property
							name=
							"messenger"
							ref=
							"messenger"
							/>
							</bean>
							</beans>

The bookingServicebean (a DefaultBookingService) can now use its private messengermember variable as normal because the Messengerinstance that was injected into it isa Messengerinstance. There is nothing special going on here, just plain Java and plain Groovy.

Hopefully the above XML snippet is self-explanatory, but don’t worry unduly if it isn’t. Keep reading for the in-depth detail on the whys and wherefores of the above configuration.

35.3 Defining beans that are backed by dynamic languages

This section describes exactly how you define Spring managed beans in any of the supported dynamic languages.

Please note that this chapter does not attempt to explain the syntax and idioms of the supported dynamic languages. For example, if you want to use Groovy to write certain of the classes in your application, then the assumption is that you already know Groovy. If you need further details about the dynamic languages themselves, please consult Section 35.6, “Further Resources”at the end of this chapter.

35.3.1 Common concepts

The steps involved in using dynamic-language-backed beans are as follows:

  • Write the test for the dynamic language source code (naturally)
  • Thenwrite the dynamic language source code itself :)
  • Define your dynamic-language-backed beans using the appropriate <lang:language/>element in the XML configuration (you can of course define such beans programmatically using the Spring API - although you will have to consult the source code for directions on how to do this as this type of advanced configuration is not covered in this chapter). Note this is an iterative step. You will need at least one bean definition per dynamic language source file (although the same dynamic language source file can of course be referenced by multiple bean definitions).

The first two steps (testing and writing your dynamic language source files) are beyond the scope of this chapter. Refer to the language specification and / or reference manual for your chosen dynamic language and crack on with developing your dynamic language source files. You willfirst want to read the rest of this chapter though, as Spring’s dynamic language support does make some (small) assumptions about the contents of your dynamic language source files.

The <lang:language/> element

The final step involves defining dynamic-language-backed bean definitions, one for each bean that you want to configure (this is no different from normal JavaBean configuration). However, instead of specifying the fully qualified classname of the class that is to be instantiated and configured by the container, you use the <lang:language/>element to define the dynamic language-backed bean.

Each of the supported languages has a corresponding <lang:language/>element:

  • <lang:jruby/>(JRuby)
  • <lang:groovy/>(Groovy)
  • <lang:bsh/>(BeanShell)

The exact attributes and child elements that are available for configuration depends on exactly which language the bean has been defined in (the language-specific sections below provide the full lowdown on this).

Refreshable beans

One of the (if not the) most compelling value adds of the dynamic language support in Spring is the 'refreshable bean'feature.

A refreshable bean is a dynamic-language-backed bean that with a small amount of configuration, a dynamic-language-backed bean can monitor changes in its underlying source file resource, and then reload itself when the dynamic language source file is changed (for example when a developer edits and saves changes to the file on the filesystem).

This allows a developer to deploy any number of dynamic language source files as part of an application, configure the Spring container to create beans backed by dynamic language source files (using the mechanisms described in this chapter), and then later, as requirements change or some other external factor comes into play, simply edit a dynamic language source file and have any change they make reflected in the bean that is backed by the changed dynamic language source file. There is no need to shut down a running application (or redeploy in the case of a web application). The dynamic-language-backed bean so amended will pick up the new state and logic from the changed dynamic language source file.

[Note] Note

Please note that this feature is offby default.

Let’s take a look at an example to see just how easy it is to start using refreshable beans. To turn onthe refreshable beans feature, you simply have to specify exactly oneadditional attribute on the <lang:language/>element of your bean definition. So if we stick with the examplefrom earlier in this chapter, here’s what we would change in the Spring XML configuration to effect refreshable beans:

									<beans>
									<!-- this bean is now 'refreshable' due to the presence of the 'refresh-check-delay' attribute -->
									<lang:groovy
									id=
									"messenger"
									refresh-check-delay=
									"5000"
									<!--
									switches
									refreshing
									on
									with
									5
									seconds
									between
									checks
									-->
									script-source=
									"classpath:Messenger.groovy"
									>
									<lang:property
									name=
									"message"
									value=
									"I Can Do The Frug"
									/>
									</lang:groovy>
									<bean
									id=
									"bookingService"
									class=
									"x.y.DefaultBookingService"
									>
									<property
									name=
									"messenger"
									ref=
									"messenger"
									/>
									</bean>
									</beans>

That really is all you have to do. The 'refresh-check-delay'attribute defined on the 'messenger'bean definition is the number of milliseconds after which the bean will be refreshed with any changes made to the underlying dynamic language source file. You can turn off the refresh behavior by assigning a negative value to the 'refresh-check-delay'attribute. Remember that, by default, the refresh behavior is disabled. If you don’t want the refresh behavior, then simply don’t define the attribute.

If we then run the following application we can exercise the refreshable feature; please do excuse the 'jumping-through-hoops-to-pause-the-execution'shenanigans in this next slice of code. The System.in.read()call is only there so that the execution of the program pauses while I (the author) go off and edit the underlying dynamic language source file so that the refresh will trigger on the dynamic-language-backed bean when the program resumes execution.

									importorg.springframework.context.ApplicationContext;
									importorg.springframework.context.support.ClassPathXmlApplicationContext;
									importorg.springframework.scripting.Messenger;
									public
									final
									classBoot {
									public
									static
									voidmain(
									finalString[] args)
									throwsException { ApplicationContext ctx =
									newClassPathXmlApplicationContext(
									"beans.xml"); Messenger messenger = (Messenger) ctx.getBean(
									"messenger"); System.out.println(messenger.getMessage());
									// pause execution while I go off and make changes to the source file...System.in.read(); System.out.println(messenger.getMessage()); } }

Let’s assume then, for the purposes of this example, that all calls to the getMessage()method of Messengerimplementations have to be changed such that the message is surrounded by quotes. Below are the changes that I (the author) make to the Messenger.groovysource file when the execution of the program is paused.

									packageorg.springframework.scripting
									classGroovyMessenger
									implementsMessenger {
									privateString message =
									"Bingo"
									publicString getMessage() {
									// change the implementation to surround the message in quotes
									return
									"'"+
									this.message +
									"'"}
									public
									voidsetMessage(String message) {
									this.message = message } }

When the program executes, the output before the input pause will be I Can Do The Frug. After the change to the source file is made and saved, and the program resumes execution, the result of calling the getMessage()method on the dynamic-language-backed Messengerimplementation will be 'I Can Do The Frug'(notice the inclusion of the additional quotes).

It is important to understand that changes to a script will nottrigger a refresh if the changes occur within the window of the 'refresh-check-delay'value. It is equally important to understand that changes to the script are notactually 'picked up' until a method is called on the dynamic-language-backed bean. It is only when a method is called on a dynamic-language-backed bean that it checks to see if its underlying script source has changed. Any exceptions relating to refreshing the script (such as encountering a compilation error, or finding that the script file has been deleted) will result in a fatalexception being propagated to the calling code.

The refreshable bean behavior described above does notapply to dynamic language source files defined using the <lang:inline-script/>element notation (see the section called “Inline dynamic language source files”). Additionally, it onlyapplies to beans where changes to the underlying source file can actually be detected; for example, by code that checks the last modified date of a dynamic language source file that exists on the filesystem.

Inline dynamic language source files

The dynamic language support can also cater for dynamic language source files that are embedded directly in Spring bean definitions. More specifically, the <lang:inline-script/>element allows you to define dynamic language source immediately inside a Spring configuration file. An example will perhaps make the inline script feature crystal clear:

									<lang:groovy
									id=
									"messenger"
									>
									<lang:inline-script>package org.springframework.scripting.groovy; import org.springframework.scripting.Messenger class GroovyMessenger implements Messenger { String message }
									</lang:inline-script>
									<lang:property
									name=
									"message"
									value=
									"I Can Do The Frug"
									/>
									</lang:groovy>

If we put to one side the issues surrounding whether it is good practice to define dynamic language source inside a Spring configuration file, the <lang:inline-script/>element can be useful in some scenarios. For instance, we might want to quickly add a Spring Validatorimplementation to a Spring MVC Controller. This is but a moment’s work using inline source. (See Section 35.4.2, “Scripted Validators”for such an example.)

Find below an example of defining the source for a JRuby-based bean directly in a Spring XML configuration file using the inline:notation. (Notice the use of the < characters to denote a '<'character. In such a case surrounding the inline source in a <![CDATA[]]>region might be better.)

									<lang:jruby
									id=
									"messenger"
									script-interfaces=
									"org.springframework.scripting.Messenger"
									>
									<lang:inline-script>require 'java' include_class 'org.springframework.scripting.Messenger' class RubyMessenger &lt; Messenger def setMessage(message) @@message = message end def getMessage @@message end end
									</lang:inline-script>
									<lang:property
									name=
									"message"
									value=
									"Hello World!"
									/>
									</lang:jruby>

Understanding Constructor Injection in the context of dynamic-language-backed beans

There is one veryimportant thing to be aware of with regard to Spring’s dynamic language support. Namely, it is not (currently) possible to supply constructor arguments to dynamic-language-backed beans (and hence constructor-injection is not available for dynamic-language-backed beans). In the interests of making this special handling of constructors and properties 100% clear, the following mixture of code and configuration will notwork.

									// from the file 'Messenger.groovy'
									packageorg.springframework.scripting.groovy;
									importorg.springframework.scripting.Messenger
									classGroovyMessenger
									implementsMessenger { GroovyMessenger() {}
									// this constructor is not available for Constructor InjectionGroovyMessenger(String message) {
									this.message = message; } String message String anotherMessage }
									<lang:groovy
									id=
									"badMessenger"
									script-source=
									"classpath:Messenger.groovy"
									>
									<!-- this next constructor argument will
									
										notbe injected into the GroovyMessenger -->
									<!-- in fact, this isn't even allowed according to the schema -->
									<constructor-arg
									value=
									"This will
									
										notwork" />
									<!-- only property values are injected into the dynamic-language-backed object -->
									<lang:property
									name=
									"anotherMessage"
									value=
									"Passed straight through to the dynamic-language-backed object"
									/>
									</lang>

In practice this limitation is not as significant as it first appears since setter injection is the injection style favored by the overwhelming majority of developers anyway (let’s leave the discussion as to whether that is a good thing to another day).

35.3.2 JRuby beans

The JRuby library dependencies

The JRuby scripting support in Spring requires the following libraries to be on the classpath of your application.

  • jruby.jar

From the JRuby homepage…​

" JRuby is an 100% pure-Java implementation of the Ruby programming language."

In keeping with the Spring philosophy of offering choice, Spring’s dynamic language support also supports beans defined in the JRuby language. The JRuby language is based on the quite intuitive Ruby language, and has support for inline regular expressions, blocks (closures), and a whole host of other features that do make solutions for some domain problems a whole lot easier to develop.

The implementation of the JRuby dynamic language support in Spring is interesting in that what happens is this: Spring creates a JDK dynamic proxy implementing all of the interfaces that are specified in the 'script-interfaces'attribute value of the <lang:ruby>element (this is why you mustsupply at least one interface in the value of the attribute, and (accordingly) program to interfaces when using JRuby-backed beans).

Let us look at a fully working example of using a JRuby-based bean. Here is the JRuby implementation of the Messengerinterface that was defined earlier in this chapter (for your convenience it is repeated below).

package org.springframework.scripting; public interface Messenger { String getMessage(); }
require
								'java'
								classRubyMessenger include org.springframework.scripting.Messenger
								defsetMessage(message) @@message = message
								end
								defgetMessage @@message
								end
								end
								# this last line is not essential (but see below)RubyMessenger.new

And here is the Spring XML that defines an instance of the RubyMessengerJRuby bean.

								<lang:jruby
								id=
								"messageService"
								script-interfaces=
								"org.springframework.scripting.Messenger"
								script-source=
								"classpath:RubyMessenger.rb"
								>
								<lang:property
								name=
								"message"
								value=
								"Hello World!"
								/>
								</lang:jruby>

Take note of the last line of that JRuby source ( 'RubyMessenger.new'). When using JRuby in the context of Spring’s dynamic language support, you are encouraged to instantiate and return a new instance of the JRuby class that you want to use as a dynamic-language-backed bean as the result of the execution of your JRuby source. You can achieve this by simply instantiating a new instance of your JRuby class on the last line of the source file like so:

require
								'java'include_class
								'org.springframework.scripting.Messenger'
								# class definition same as above...
								# instantiate and return a new instance of the RubyMessenger classRubyMessenger.new

If you forget to do this, it is not the end of the world; this will however result in Spring having to trawl (reflectively) through the type representation of your JRuby class looking for a class to instantiate. In the grand scheme of things this will be so fast that you’ll never notice it, but it is something that can be avoided by simply having a line such as the one above as the last line of your JRuby script. If you don’t supply such a line, or if Spring cannot find a JRuby class in your script to instantiate then an opaque ScriptCompilationExceptionwill be thrown immediately after the source is executed by the JRuby interpreter. The key text that identifies this as the root cause of an exception can be found immediately below (so if your Spring container throws the following exception when creating your dynamic-language-backed bean and the following text is there in the corresponding stacktrace, this will hopefully allow you to identify and then easily rectify the issue):

org.springframework.scripting.ScriptCompilationException: Compilation of JRuby script returned ''

To rectify this, simply instantiate a new instance of whichever class you want to expose as a JRuby-dynamic-language-backed bean (as shown above). Please also note that you can actually define as many classes and objects as you want in your JRuby script; what is important is that the source file as a whole must return an object (for Spring to configure).

See Section 35.4, “Scenarios”for some scenarios where you might want to use JRuby-based beans.

35.3.3 Groovy beans

The Groovy library dependencies

The Groovy scripting support in Spring requires the following libraries to be on the classpath of your application.

  • groovy-1.8.jar
  • asm-3.2.jar
  • antlr-2.7.7.jar

From the Groovy homepage…​

" Groovy is an agile dynamic language for the Java 2 Platform that has many of the features that people like so much in languages like Python, Ruby and Smalltalk, making them available to Java developers using a Java-like syntax."

If you have read this chapter straight from the top, you will already have seen an exampleof a Groovy-dynamic-language-backed bean. Let’s look at another example (again using an example from the Spring test suite).

								packageorg.springframework.scripting;
								public
								interfaceCalculator {
								intadd(
								intx,
								inty); }

Here is an implementation of the Calculatorinterface in Groovy.

								// from the file 'calculator.groovy'
								packageorg.springframework.scripting.groovy
								classGroovyCalculator
								implementsCalculator {
								intadd(
								intx,
								inty) { x + y } }
								<--
								from
								the
								file
								'beans.xml'
								-->
								<beans>
								<lang:groovy
								id=
								"calculator"
								script-source=
								"classpath:calculator.groovy"
								/>
								</beans>

Lastly, here is a small application to exercise the above configuration.

								packageorg.springframework.scripting;
								importorg.springframework.context.ApplicationContext;
								importorg.springframework.context.support.ClassPathXmlApplicationContext;
								public
								classMain {
								public
								static
								voidMain(String[] args) { ApplicationContext ctx =
								newClassPathXmlApplicationContext(
								"beans.xml"); Calculator calc = (Calculator) ctx.getBean(
								"calculator"); System.out.println(calc.add(
								2,
								8)); } }

The resulting output from running the above program will be (unsurprisingly) 10. (Exciting example, huh? Remember that the intent is to illustrate the concept. Please consult the dynamic language showcase project for a more complex example, or indeed Section 35.4, “Scenarios”later in this chapter).

It is important that you do notdefine more than one class per Groovy source file. While this is perfectly legal in Groovy, it is (arguably) a bad practice: in the interests of a consistent approach, you should (in the opinion of this author) respect the standard Java conventions of one (public) class per source file.

Customizing Groovy objects via a callback

The GroovyObjectCustomizerinterface is a callback that allows you to hook additional creation logic into the process of creating a Groovy-backed bean. For example, implementations of this interface could invoke any required initialization method(s), or set some default property values, or specify a custom MetaClass.

									public
									interfaceGroovyObjectCustomizer {
									voidcustomize(GroovyObject goo); }

The Spring Framework will instantiate an instance of your Groovy-backed bean, and will then pass the created GroovyObjectto the specified GroovyObjectCustomizerif one has been defined. You can do whatever you like with the supplied GroovyObjectreference: it is expected that the setting of a custom MetaClassis what most folks will want to do with this callback, and you can see an example of doing that below.

									public
									final
									classSimpleMethodTracingCustomizer
									implementsGroovyObjectCustomizer {
									public
									voidcustomize(GroovyObject goo) { DelegatingMetaClass metaClass =
									newDelegatingMetaClass(goo.getMetaClass()) {
									publicObject invokeMethod(Object object, String methodName, Object[] arguments) { System.out.println(
									"Invoking '"+ methodName +
									"'.");
									return
									super.invokeMethod(object, methodName, arguments); } }; metaClass.initialize(); goo.setMetaClass(metaClass); } }

A full discussion of meta-programming in Groovy is beyond the scope of the Spring reference manual. Consult the relevant section of the Groovy reference manual, or do a search online: there are plenty of articles concerning this topic. Actually making use of a GroovyObjectCustomizeris easy if you are using the Spring namespace support.

									<!-- define the GroovyObjectCustomizer just like any other bean -->
									<bean
									id=
									"tracingCustomizer"
									class=
									"example.SimpleMethodTracingCustomizer"
									/>
									<!-- ... and plug it into the desired Groovy bean via the 'customizer-ref' attribute -->
									<lang:groovy
									id=
									"calculator"
									script-source=
									"classpath:org/springframework/scripting/groovy/Calculator.groovy"
									customizer-ref=
									"tracingCustomizer"
									/>

If you are not using the Spring namespace support, you can still use the GroovyObjectCustomizerfunctionality.

									<bean
									id=
									"calculator"
									class=
									"org.springframework.scripting.groovy.GroovyScriptFactory"
									>
									<constructor-arg
									value=
									"classpath:org/springframework/scripting/groovy/Calculator.groovy"
									/>
									<!-- define the GroovyObjectCustomizer (as an inner bean) -->
									<constructor-arg>
									<bean
									id=
									"tracingCustomizer"
									class=
									"example.SimpleMethodTracingCustomizer"
									/>
									</constructor-arg>
									</bean>
									<bean
									class=
									"org.springframework.scripting.support.ScriptFactoryPostProcessor"
									/>
[Note] Note

As of Spring Framework 4.3.3, you may also specify a Groovy CompilationCustomizer(such as an ImportCustomizer) or even a full Groovy CompilerConfigurationobject in the same place as Spring’s GroovyObjectCustomizer.

35.3.4 BeanShell beans

The BeanShell library dependencies

The BeanShell scripting support in Spring requires the following libraries to be on the classpath of your application.

  • bsh-2.0b4.jar

From the BeanShell homepage…​

" BeanShell is a small, free, embeddable Java source interpreter with dynamic language features, written in Java. BeanShell dynamically executes standard Java syntax and extends it with common scripting conveniences such as loose types, commands, and method closures like those in Perl and JavaScript."

In contrast to Groovy, BeanShell-backed bean definitions require some (small) additional configuration. The implementation of the BeanShell dynamic language support in Spring is interesting in that what happens is this: Spring creates a JDK dynamic proxy implementing all of the interfaces that are specified in the 'script-interfaces'attribute value of the <lang:bsh>element (this is why you mustsupply at least one interface in the value of the attribute, and (accordingly) program to interfaces when using BeanShell-backed beans). This means that every method call on a BeanShell-backed object is going through the JDK dynamic proxy invocation mechanism.

Let’s look at a fully working example of using a BeanShell-based bean that implements the Messengerinterface that was defined earlier in this chapter (repeated below for your convenience).

								packageorg.springframework.scripting;
								public
								interfaceMessenger { String getMessage(); }

Here is the BeanShell 'implementation' (the term is used loosely here) of the Messengerinterface.

String message; String getMessage() {
								returnmessage; }
								voidsetMessage(String aMessage) { message = aMessage; }

And here is the Spring XML that defines an 'instance' of the above 'class' (again, the term is used very loosely here).

								<lang:bsh
								id=
								"messageService"
								script-source=
								"classpath:BshMessenger.bsh"
								script-interfaces=
								"org.springframework.scripting.Messenger"
								>
								<lang:property
								name=
								"message"
								value=
								"Hello World!"
								/>
								</lang:bsh>

See Section 35.4, “Scenarios”for some scenarios where you might want to use BeanShell-based beans.

35.4 Scenarios

The possible scenarios where defining Spring managed beans in a scripting language would be beneficial are, of course, many and varied. This section describes two possible use cases for the dynamic language support in Spring.

35.4.1 Scripted Spring MVC Controllers

One group of classes that may benefit from using dynamic-language-backed beans is that of Spring MVC controllers. In pure Spring MVC applications, the navigational flow through a web application is to a large extent determined by code encapsulated within your Spring MVC controllers. As the navigational flow and other presentation layer logic of a web application needs to be updated to respond to support issues or changing business requirements, it may well be easier to effect any such required changes by editing one or more dynamic language source files and seeing those changes being immediately reflected in the state of a running application.

Remember that in the lightweight architectural model espoused by projects such as Spring, you are typically aiming to have a really thinpresentation layer, with all the meaty business logic of an application being contained in the domain and service layer classes. Developing Spring MVC controllers as dynamic-language-backed beans allows you to change presentation layer logic by simply editing and saving text files; any changes to such dynamic language source files will (depending on the configuration) automatically be reflected in the beans that are backed by dynamic language source files.

[Note] Note

In order to effect this automatic 'pickup' of any changes to dynamic-language-backed beans, you will have had to enable the 'refreshable beans' functionality. See the section called “Refreshable beans”for a full treatment of this feature.

Find below an example of an org.springframework.web.servlet.mvc.Controllerimplemented using the Groovy dynamic language.

								// from the file '/WEB-INF/groovy/FortuneController.groovy'
								packageorg.springframework.showcase.fortune.web
								importorg.springframework.showcase.fortune.service.FortuneService
								importorg.springframework.showcase.fortune.domain.Fortune
								importorg.springframework.web.servlet.ModelAndView
								importorg.springframework.web.servlet.mvc.Controller
								importjavax.servlet.http.HttpServletRequest
								importjavax.servlet.http.HttpServletResponse
								classFortuneController
								implementsController {
								
									@PropertyFortuneService fortuneService ModelAndView handleRequest(HttpServletRequest request, HttpServletResponse httpServletResponse) {
								return
								newModelAndView(
								"tell",
								"fortune",
								this.fortuneService.tellFortune()) } }
								<lang:groovy
								id=
								"fortune"
								refresh-check-delay=
								"3000"
								script-source=
								"/WEB-INF/groovy/FortuneController.groovy"
								>
								<lang:property
								name=
								"fortuneService"
								ref=
								"fortuneService"
								/>
								</lang:groovy>

35.4.2 Scripted Validators

Another area of application development with Spring that may benefit from the flexibility afforded by dynamic-language-backed beans is that of validation. It maybe easier to express complex validation logic using a loosely typed dynamic language (that may also have support for inline regular expressions) as opposed to regular Java.

Again, developing validators as dynamic-language-backed beans allows you to change validation logic by simply editing and saving a simple text file; any such changes will (depending on the configuration) automatically be reflected in the execution of a running application and would not require the restart of an application.

[Note] Note

Please note that in order to effect the automatic 'pickup' of any changes to dynamic-language-backed beans, you will have had to enable the 'refreshable beans' feature. See the section called “Refreshable beans”for a full and detailed treatment of this feature.

Find below an example of a Spring org.springframework.validation.Validatorimplemented using the Groovy dynamic language. (See Section 9.2, “Validation using Spring’s Validator interface”for a discussion of the Validatorinterface.)

								importorg.springframework.validation.Validator
								importorg.springframework.validation.Errors
								importorg.springframework.beans.TestBean
								classTestBeanValidator
								implementsValidator {
								booleansupports(Class clazz) {
								returnTestBean.
								class.isAssignableFrom(clazz) }
								voidvalidate(Object bean, Errors errors) {
								if(bean.name?.trim()?.size() >
								0) {
								return} errors.reject(
								"whitespace",
								"Cannot be composed wholly of whitespace.") } }

35.5 Bits and bobs

This last section contains some bits and bobs related to the dynamic language support.

35.5.1 AOP - advising scripted beans

It is possible to use the Spring AOP framework to advise scripted beans. The Spring AOP framework actually is unaware that a bean that is being advised might be a scripted bean, so all of the AOP use cases and functionality that you may be using or aim to use will work with scripted beans. There is just one (small) thing that you need to be aware of when advising scripted beans…​ you cannot use class-based proxies, you must use interface-based proxies.

You are of course not just limited to advising scripted beans…​ you can also write aspects themselves in a supported dynamic language and use such beans to advise other Spring beans. This really would be an advanced use of the dynamic language support though.

35.5.2 Scoping

In case it is not immediately obvious, scripted beans can of course be scoped just like any other bean. The scopeattribute on the various <lang:language/>elements allows you to control the scope of the underlying scripted bean, just as it does with a regular bean. (The default scope is singleton, just as it is with 'regular' beans.)

Find below an example of using the scopeattribute to define a Groovy bean scoped as a prototype.

								<?xml version="1.0" encoding="UTF-8"?>
								<beans
								xmlns=
								"http://www.springframework.org/schema/beans"
								xmlns:xsi=
								"http://www.w3.org/2001/XMLSchema-instance"
								xmlns:lang=
								"http://www.springframework.org/schema/lang"
								xsi:schemaLocation=
								" http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/lang http://www.springframework.org/schema/lang/spring-lang.xsd"
								>
								<lang:groovy
								id=
								"messenger"
								script-source=
								"classpath:Messenger.groovy"
								scope=
								"prototype"
								>
								<lang:property
								name=
								"message"
								value=
								"I Can Do The RoboCop"
								/>
								</lang:groovy>
								<bean
								id=
								"bookingService"
								class=
								"x.y.DefaultBookingService"
								>
								<property
								name=
								"messenger"
								ref=
								"messenger"
								/>
								</bean>
								</beans>

See Section 7.5, “Bean scopes”in Chapter 7, The IoC container for a fuller discussion of the scoping support in the Spring Framework.

35.6 Further Resources

Find below links to further resources about the various dynamic languages described in this chapter.

36. Cache Abstraction

36.1 Introduction

Since version 3.1, Spring Framework provides support for transparently adding caching into an existing Spring application. Similar to the transactionsupport, the caching abstraction allows consistent use of various caching solutions with minimal impact on the code.

As from Spring 4.1, the cache abstraction has been significantly improved with the support of JSR-107 annotationsand more customization options.

36.2 Understanding the cache abstraction

Cache vs Buffer

The terms "buffer" and "cache" tend to be used interchangeably; note however they represent different things. A buffer is used traditionally as an intermediate temporary store for data between a fast and a slow entity. As one party would have to waitfor the other affecting performance, the buffer alleviates this by allowing entire blocks of data to move at once rather then in small chunks. The data is written and read only once from the buffer. Furthermore, the buffers are visibleto at least one party which is aware of it.

A cache on the other hand by definition is hidden and neither party is aware that caching occurs.It as well improves performance but does that by allowing the same data to be read multiple times in a fast fashion.

A further explanation of the differences between two can be found here.

At its core, the abstraction applies caching to Java methods, reducing thus the number of executions based on the information available in the cache. That is, each time a targetedmethod is invoked, the abstraction will apply a caching behavior checking whether the method has been already executed for the given arguments. If it has, then the cached result is returned without having to execute the actual method; if it has not, then method is executed, the result cached and returned to the user so that, the next time the method is invoked, the cached result is returned. This way, expensive methods (whether CPU or IO bound) can be executed only once for a given set of parameters and the result reused without having to actually execute the method again. The caching logic is applied transparently without any interference to the invoker.

[Important] Important

Obviously this approach works only for methods that are guaranteed to return the same output (result) for a given input (or arguments) no matter how many times it is being executed.

Other cache-related operations are provided by the abstraction such as the ability to update the content of the cache or remove one of all entries. These are useful if the cache deals with data that can change during the course of the application.

Just like other services in the Spring Framework, the caching service is an abstraction (not a cache implementation) and requires the use of an actual storage to store the cache data - that is, the abstraction frees the developer from having to write the caching logic but does not provide the actual stores. This abstraction is materialized by the org.springframework.cache.Cacheand org.springframework.cache.CacheManagerinterfaces.

There are a few implementationsof that abstraction available out of the box: JDK java.util.concurrent.ConcurrentMapbased caches, Ehcache 2.x, Gemfire cache, Caffeine, Guava cachesand JSR-107 compliant caches (e.g. Ehcache 3.x). See Section 36.7, “Plugging-in different back-end caches”for more information on plugging in other cache stores/providers.

[Important] Important

The caching abstraction has no special handling of multi-threaded and multi-process environments as such features are handled by the cache implementation. .

If you have a multi-process environment (i.e. an application deployed on several nodes), you will need to configure your cache provider accordingly. Depending on your use cases, a copy of the same data on several nodes may be enough but if you change the data during the course of the application, you may need to enable other propagation mechanisms.

Caching a particular item is a direct equivalent of the typical get-if-not-found-then- proceed-and-put-eventually code blocks found with programmatic cache interaction: no locks are applied and several threads may try to load the same item concurrently. The same applies to eviction: if several threads are trying to update or evict data concurrently, you may use stale data. Certain cache providers offer advanced features in that area, refer to the documentation of the cache provider that you are using for more details.

To use the cache abstraction, the developer needs to take care of two aspects:

  • caching declaration - identify the methods that need to be cached and their policy
  • cache configuration - the backing cache where the data is stored and read from

36.3 Declarative annotation-based caching

For caching declaration, the abstraction provides a set of Java annotations:

  • @Cacheabletriggers cache population
  • @CacheEvicttriggers cache eviction
  • @CachePutupdates the cache without interfering with the method execution
  • @Cachingregroups multiple cache operations to be applied on a method
  • @CacheConfigshares some common cache-related settings at class-level

Let us take a closer look at each annotation:

36.3.1 @Cacheable annotation

As the name implies, @Cacheableis used to demarcate methods that are cacheable - that is, methods for whom the result is stored into the cache so on subsequent invocations (with the same arguments), the value in the cache is returned without having to actually execute the method. In its simplest form, the annotation declaration requires the name of the cache associated with the annotated method:

								
									@Cacheable("books")
								publicBook findBook(ISBN isbn) {...}

In the snippet above, the method findBookis associated with the cache named books. Each time the method is called, the cache is checked to see whether the invocation has been already executed and does not have to be repeated. While in most cases, only one cache is declared, the annotation allows multiple names to be specified so that more than one cache are being used. In this case, each of the caches will be checked before executing the method - if at least one cache is hit, then the associated value will be returned:

[Note] Note

All the other caches that do not contain the value will be updated as well even though the cached method was not actually executed.

 
								
									@Cacheable({"books", "isbns"})
								publicBook findBook(ISBN isbn) {...}

Default Key Generation

Since caches are essentially key-value stores, each invocation of a cached method needs to be translated into a suitable key for cache access. Out of the box, the caching abstraction uses a simple KeyGeneratorbased on the following algorithm:

  • If no params are given, return SimpleKey.EMPTY.
  • If only one param is given, return that instance.
  • If more the one param is given, return a SimpleKeycontaining all parameters.

This approach works well for most use-cases; As long as parameters have natural keysand implement valid hashCode()and equals()methods. If that is not the case then the strategy needs to be changed.

To provide a different defaultkey generator, one needs to implement the org.springframework.cache.interceptor.KeyGeneratorinterface.

[Note] Note

The default key generation strategy changed with the release of Spring 4.0. Earlier versions of Spring used a key generation strategy that, for multiple key parameters, only considered the hashCode()of parameters and not equals(); this could cause unexpected key collisions (see SPR-10237for background). The new 'SimpleKeyGenerator' uses a compound key for such scenarios.

If you want to keep using the previous key strategy, you can configure the deprecated org.springframework.cache.interceptor.DefaultKeyGeneratorclass or create a custom hash-based 'KeyGenerator' implementation.

Custom Key Generation Declaration

Since caching is generic, it is quite likely the target methods have various signatures that cannot be simply mapped on top of the cache structure. This tends to become obvious when the target method has multiple arguments out of which only some are suitable for caching (while the rest are used only by the method logic). For example:

									
										@Cacheable("books")
									publicBook findBook(ISBN isbn,
									booleancheckWarehouse,
									booleanincludeUsed)

At first glance, while the two booleanarguments influence the way the book is found, they are no use for the cache. Further more what if only one of the two is important while the other is not?

For such cases, the @Cacheableannotation allows the user to specify how the key is generated through its keyattribute. The developer can use SpELto pick the arguments of interest (or their nested properties), perform operations or even invoke arbitrary methods without having to write any code or implement any interface. This is the recommended approach over the default generatorsince methods tend to be quite different in signatures as the code base grows; while the default strategy might work for some methods, it rarely does for all methods.

Below are some examples of various SpEL declarations - if you are not familiar with it, do yourself a favor and read Chapter 10, Spring Expression Language (SpEL) :

@Cacheable(cacheNames=
									"books",
									
										key="#isbn")
									publicBook findBook(ISBN isbn,
									booleancheckWarehouse,
									booleanincludeUsed) @Cacheable(cacheNames=
									"books",
									
										key="#isbn.rawNumber")
									publicBook findBook(ISBN isbn,
									booleancheckWarehouse,
									booleanincludeUsed) @Cacheable(cacheNames=
									"books",
									
										key="T(someType).hash(#isbn)")
									publicBook findBook(ISBN isbn,
									booleancheckWarehouse,
									booleanincludeUsed)

The snippets above show how easy it is to select a certain argument, one of its properties or even an arbitrary (static) method.

If the algorithm responsible to generate the key is too specific or if it needs to be shared, you may define a custom keyGeneratoron the operation. To do this, specify the name of the KeyGeneratorbean implementation to use:

@Cacheable(cacheNames=
									"books",
									
										keyGenerator="myKeyGenerator")
									publicBook findBook(ISBN isbn,
									booleancheckWarehouse,
									booleanincludeUsed)
[Note] Note

The keyand keyGeneratorparameters are mutually exclusive and an operation specifying both will result in an exception.

Default Cache Resolution

Out of the box, the caching abstraction uses a simple CacheResolverthat retrieves the cache(s) defined at the operation level using the configured CacheManager.

To provide a different defaultcache resolver, one needs to implement the org.springframework.cache.interceptor.CacheResolverinterface.

Custom cache resolution

The default cache resolution fits well for applications working with a single CacheManagerand with no complex cache resolution requirements.

For applications working with several cache managers, it is possible to set the cacheManagerto use per operation:

@Cacheable(cacheNames=
									"books",
									
										cacheManager="anotherCacheManager")
									publicBook findBook(ISBN isbn) {...}

It is also possible to replace the CacheResolverentirely in a similar fashion as for key generation. The resolution is requested for every cache operation, giving a chance to the implementation to actually resolve the cache(s) to use based on runtime arguments:

@Cacheable(
									
										cacheResolver="runtimeCacheResolver")
									publicBook findBook(ISBN isbn) {...}
[Note] Note

Since Spring 4.1, the valueattribute of the cache annotations are no longer mandatory since this particular information can be provided by the CacheResolverregardless of the content of the annotation.

Similarly to keyand keyGenerator, the cacheManagerand cacheResolverparameters are mutually exclusive and an operation specifying both will result in an exception as a custom CacheManagerwill be ignored by the CacheResolverimplementation. This is probably not what you expect.

Synchronized caching

In a multi-threaded environment, certain operations might be concurrently invoked for the same argument (typically on startup). By default, the cache abstraction does not lock anything and the same value may be computed several times, defeating the purpose of caching.

For those particular cases, the syncattribute can be used to instruct the underlying cache provider to lockthe cache entry while the value is being computed. As a result, only one thread will be busy computing the value while the others are blocked until the entry is updated in the cache.

@Cacheable(cacheNames=
									"foos",
									
										sync="true")
									publicFoo executeExpensiveOperation(String id) {...}
[Note] Note

This is an optional feature and your favorite cache library may not support it. All CacheManagerimplementations provided by the core framework support it. Check the documentation of your cache provider for more details.

Conditional caching

Sometimes, a method might not be suitable for caching all the time (for example, it might depend on the given arguments). The cache annotations support such functionality through the conditionparameter which takes a SpELexpression that is evaluated to either trueor false. If true, the method is cached - if not, it behaves as if the method is not cached, that is executed every time no matter what values are in the cache or what arguments are used. A quick example - the following method will be cached only if the argument namehas a length shorter than 32:

@Cacheable(cacheNames=
									"book",
									
										condition="#name.length < 32")
									publicBook findBook(String name)

In addition the conditionparameter, the unlessparameter can be used to veto the adding of a value to the cache. Unlike condition, unlessexpressions are evaluated afterthe method has been called. Expanding on the previous example - perhaps we only want to cache paperback books:

@Cacheable(cacheNames=
									"book", condition=
									"#name.length < 32",
									
										unless="#result.hardback")
									publicBook findBook(String name)

The cache abstraction supports java.util.Optional, using its content as cached value only if it present. #resultalways refers to the business entity and never on a supported wrapper so the previous example can be rewritten as follows:

@Cacheable(cacheNames=
									"book", condition=
									"#name.length < 32",
									
										unless="#result.hardback")
									publicOptional<Book> findBook(String name)

Note that resultstill refers to Bookand not Optional.

Available caching SpEL evaluation context

Each SpELexpression evaluates again a dedicated context. In addition to the build in parameters, the framework provides dedicated caching related metadata such as the argument names. The next table lists the items made available to the context so one can use them for key and conditional computations:

Table 36.1. Cache SpEL available metadata

Name Location Description Example

methodName

root object

The name of the method being invoked

#root.methodName

method

root object

The method being invoked

#root.method.name

target

root object

The target object being invoked

#root.target

targetClass

root object

The class of the target being invoked

#root.targetClass

args

root object

The arguments (as array) used for invoking the target

#root.args[0]

caches

root object

Collection of caches against which the current method is executed

#root.caches[0].name

argument name

evaluation context

Name of any of the method arguments. If for some reason the names are not available (e.g. no debug information), the argument names are also available under the #a<#arg>where #argstands for the argument index (starting from 0).

#ibanor #a0(one can also use #p0or #p<#arg>notation as an alias).

result

evaluation context

The result of the method call (the value to be cached). Only available in unlessexpressions, cache putexpressions (to compute the key), or cache evictexpressions (when beforeInvocationis false). For supported wrappers such as Optional, #resultrefers to the actual object, not the wrapper.

#result

36.3.2 @CachePut annotation

For cases where the cache needs to be updated without interfering with the method execution, one can use the @CachePutannotation. That is, the method will always be executed and its result placed into the cache (according to the @CachePutoptions). It supports the same options as @Cacheableand should be used for cache population rather than method flow optimization:

								
									@CachePut(cacheNames="book", key="#isbn")
								publicBook updateBook(ISBN isbn, BookDescriptor descriptor)
[Important] Important

Note that using @CachePutand @Cacheableannotations on the same method is generally strongly discouraged because they have different behaviors. While the latter causes the method execution to be skipped by using the cache, the former forces the execution in order to execute a cache update. This leads to unexpected behavior and with the exception of specific corner-cases (such as annotations having conditions that exclude them from each other), such declaration should be avoided. Note also that such condition should not rely on the result object (i.e. the #resultvariable) as these are validated upfront to confirm the exclusion.

36.3.3 @CacheEvict annotation

The cache abstraction allows not just population of a cache store but also eviction. This process is useful for removing stale or unused data from the cache. Opposed to @Cacheable, annotation @CacheEvictdemarcates methods that perform cache eviction, that is methods that act as triggers for removing data from the cache. Just like its sibling, @CacheEvictrequires specifying one (or multiple) caches that are affected by the action, allows a custom cache and key resolution or a condition to be specified but in addition, features an extra parameter allEntrieswhich indicates whether a cache-wide eviction needs to be performed rather then just an entry one (based on the key):

@CacheEvict(cacheNames=
								"books",
								
									allEntries=true)
								public
								voidloadBooks(InputStream batch)

This option comes in handy when an entire cache region needs to be cleared out - rather then evicting each entry (which would take a long time since it is inefficient), all the entries are removed in one operation as shown above. Note that the framework will ignore any key specified in this scenario as it does not apply (the entire cache is evicted not just one entry).

One can also indicate whether the eviction should occur after (the default) or before the method executes through the beforeInvocationattribute. The former provides the same semantics as the rest of the annotations - once the method completes successfully, an action (in this case eviction) on the cache is executed. If the method does not execute (as it might be cached) or an exception is thrown, the eviction does not occur. The latter ( beforeInvocation=true) causes the eviction to occur always, before the method is invoked - this is useful in cases where the eviction does not need to be tied to the method outcome.

It is important to note that void methods can be used with @CacheEvict- as the methods act as triggers, the return values are ignored (as they don’t interact with the cache) - this is not the case with @Cacheablewhich adds/updates data into the cache and thus requires a result.

36.3.4 @Caching annotation

There are cases when multiple annotations of the same type, such as @CacheEvictor @CachePutneed to be specified, for example because the condition or the key expression is different between different caches. @Cachingallows multiple nested @Cacheable, @CachePutand @CacheEvictto be used on the same method:

								
									@Caching(evict = { @CacheEvict("primary"), @CacheEvict(cacheNames="secondary", key="#p0") })
								publicBook importBooks(String deposit, Date date)

36.3.5 @CacheConfig annotation

So far we have seen that caching operations offered many customization options and these can be set on an operation basis. However, some of the customization options can be tedious to configure if they apply to all operations of the class. For instance, specifying the name of the cache to use for every cache operation of the class could be replaced by a single class-level definition. This is where @CacheConfigcomes into play.

								
									@CacheConfig("books")
								public
								classBookRepositoryImpl
								implementsBookRepository {
								
									@Cacheable
								publicBook findBook(ISBN isbn) {...} }

@CacheConfigis a class-level annotation that allows to share the cache names, the custom KeyGenerator, the custom CacheManagerand finally the custom CacheResolver. Placing this annotation on the class does not turn on any caching operation.

An operation-level customization will always override a customization set on @CacheConfig. This gives therefore three levels of customizations per cache operation:

  • Globally configured, available for CacheManager, KeyGenerator
  • At class level, using @CacheConfig
  • At the operation level

36.3.6 Enable caching annotations

It is important to note that even though declaring the cache annotations does not automatically trigger their actions - like many things in Spring, the feature has to be declaratively enabled (which means if you ever suspect caching is to blame, you can disable it by removing only one configuration line rather than all the annotations in your code).

To enable caching annotations add the annotation @EnableCachingto one of your @Configurationclasses:

								
									@Configuration
								
									@EnableCaching
								public
								classAppConfig { }

Alternatively for XML configuration use the cache:annotation-drivenelement:

								<beans
								xmlns=
								"http://www.springframework.org/schema/beans"
								xmlns:xsi=
								"http://www.w3.org/2001/XMLSchema-instance"
								xmlns:cache=
								"http://www.springframework.org/schema/cache"
								xsi:schemaLocation=
								" http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/cache http://www.springframework.org/schema/cache/spring-cache.xsd"
								>
								<cache:annotation-driven />
								</beans>

Both the cache:annotation-drivenelement and @EnableCachingannotation allow various options to be specified that influence the way the caching behavior is added to the application through AOP. The configuration is intentionally similar with that of @Transactional:

[Note] Note

Advanced customizations using Java config require to implement CachingConfigurer, refer to the javadoc for more details.

Table 36.2. Cache annotation settings

XML Attribute Annotation Attribute Default Description

cache-manager

N/A (See CachingConfigurerjavadocs)

cacheManager

Name of cache manager to use. A default CacheResolverwill be initialized behind the scenes with this cache manager (or `cacheManager`if not set). For more fine-grained management of the cache resolution, consider setting the 'cache-resolver' attribute.

cache-resolver

N/A (See CachingConfigurerjavadocs)

A SimpleCacheResolverusing the configured cacheManager.

The bean name of the CacheResolver that is to be used to resolve the backing caches. This attribute is not required, and only needs to be specified as an alternative to the 'cache-manager' attribute.

key-generator

N/A (See CachingConfigurerjavadocs)

SimpleKeyGenerator

Name of the custom key generator to use.

error-handler

N/A (See CachingConfigurerjavadocs)

SimpleCacheErrorHandler

Name of the custom cache error handler to use. By default, any exception throw during a cache related operations are thrown back at the client.

mode

mode

proxy

The default mode "proxy" processes annotated beans to be proxied using Spring’s AOP framework (following proxy semantics, as discussed above, applying to method calls coming in through the proxy only). The alternative mode "aspectj" instead weaves the affected classes with Spring’s AspectJ caching aspect, modifying the target class byte code to apply to any kind of method call. AspectJ weaving requires spring-aspects.jar in the classpath as well as load-time weaving (or compile-time weaving) enabled. (See the section called “Spring configuration”for details on how to set up load-time weaving.)

proxy-target-class

proxyTargetClass

false

Applies to proxy mode only. Controls what type of caching proxies are created for classes annotated with the @Cacheableor @CacheEvictannotations. If the proxy-target-classattribute is set to true, then class-based proxies are created. If proxy-target-classis falseor if the attribute is omitted, then standard JDK interface-based proxies are created. (See Section 11.6, “Proxying mechanisms”for a detailed examination of the different proxy types.)

order

order

Ordered.LOWEST_PRECEDENCE

Defines the order of the cache advice that is applied to beans annotated with @Cacheableor @CacheEvict. (For more information about the rules related to ordering of AOP advice, see the section called “Advice ordering”.) No specified ordering means that the AOP subsystem determines the order of the advice.

[Note] Note

<cache:annotation-driven/>only looks for @Cacheable/@CachePut/@CacheEvict/@Cachingon beans in the same application context it is defined in. This means that, if you put <cache:annotation-driven/>in a WebApplicationContextfor a DispatcherServlet, it only checks for beans in your controllers, and not your services. See Section 22.2, “The DispatcherServlet”for more information.

Method visibility and cache annotations

When using proxies, you should apply the cache annotations only to methods with publicvisibility. If you do annotate protected, private or package-visible methods with these annotations, no error is raised, but the annotated method does not exhibit the configured caching settings. Consider the use of AspectJ (see below) if you need to annotate non-public methods as it changes the bytecode itself.

[Tip] Tip

Spring recommends that you only annotate concrete classes (and methods of concrete classes) with the @Cache*annotation, as opposed to annotating interfaces. You certainly can place the @Cache*annotation on an interface (or an interface method), but this works only as you would expect it to if you are using interface-based proxies. The fact that Java annotations are not inherited from interfacesmeans that if you are using class-based proxies ( proxy-target-class="true") or the weaving-based aspect ( mode="aspectj"), then the caching settings are not recognized by the proxying and weaving infrastructure, and the object will not be wrapped in a caching proxy, which would be decidedly bad.
[Note] Note

In proxy mode (which is the default), only external method calls coming in through the proxy are intercepted. This means that self-invocation, in effect, a method within the target object calling another method of the target object, will not lead to an actual caching at runtime even if the invoked method is marked with @Cacheable- considering using the aspectj mode in this case. Also, the proxy must be fully initialized to provide the expected behaviour so you should not rely on this feature in your initialization code, i.e. @PostConstruct.

36.3.7 Using custom annotations

Custom annotation and AspectJ

This feature only works out-of-the-box with the proxy-based approach but can be enabled with a bit of extra effort using AspectJ.

The spring-aspectsmodule defines an aspect for the standard annotations only. If you have defined your own annotations, you also need to define an aspect for those. Check AnnotationCacheAspectfor an example.

The caching abstraction allows you to use your own annotations to identify what method triggers cache population or eviction. This is quite handy as a template mechanism as it eliminates the need to duplicate cache annotation declarations (especially useful if the key or condition are specified) or if the foreign imports ( org.springframework) are not allowed in your code base. Similar to the rest of the stereotypeannotations, @Cacheable, @CachePut, @CacheEvictand @CacheConfigcan be used as meta-annotations, that is annotations that can annotate other annotations. To wit, let us replace a common @Cacheabledeclaration with our own, custom annotation:

								
									@Retention(RetentionPolicy.RUNTIME)
								
									@Target({ElementType.METHOD})
								
									@Cacheable(cacheNames="books", key="#isbn")
								public
								
									@interfaceSlowService { }

Above, we have defined our own SlowServiceannotation which itself is annotated with @Cacheable- now we can replace the following code:

								
									@Cacheable(cacheNames="books", key="#isbn")
								publicBook findBook(ISBN isbn,
								booleancheckWarehouse,
								booleanincludeUsed)

with:

								
									@SlowService
								publicBook findBook(ISBN isbn,
								booleancheckWarehouse,
								booleanincludeUsed)

Even though @SlowServiceis not a Spring annotation, the container automatically picks up its declaration at runtime and understands its meaning. Note that as mentioned above, the annotation-driven behavior needs to be enabled.

36.4 JCache (JSR-107) annotations

Since the Spring Framework 4.1, the caching abstraction fully supports the JCache standard annotations: these are @CacheResult, @CachePut, @CacheRemoveand @CacheRemoveAllas well as the @CacheDefaults, @CacheKeyand @CacheValuecompanions. These annotations can be used right the way without migrating your cache store to JSR-107: the internal implementation uses Spring’s caching abstraction and provides default CacheResolverand KeyGeneratorimplementations that are compliant with the specification. In other words, if you are already using Spring’s caching abstraction, you can switch to these standard annotations without changing your cache storage (or configuration, for that matter).

36.4.1 Features summary

For those who are familiar with Spring’s caching annotations, the following table describes the main differences between the Spring annotations and the JSR-107 counterpart:

Table 36.3. Spring vs. JSR-107 caching annotations

Spring JSR-107 Remark

@Cacheable

@CacheResult

Fairly similar. @CacheResultcan cache specific exceptions and force the execution of the method regardless of the content of the cache.

@CachePut

@CachePut

While Spring updates the cache with the result of the method invocation, JCache requires to pass it as an argument that is annotated with @CacheValue. Due to this difference, JCache allows to update the cache before or after the actual method invocation.

@CacheEvict

@CacheRemove

Fairly similar. @CacheRemovesupports a conditional evict in case the method invocation results in an exception.

@CacheEvict(allEntries=true)

@CacheRemoveAll

See @CacheRemove.

@CacheConfig

@CacheDefaults

Allows to configure the same concepts, in a similar fashion.

JCache has the notion of javax.cache.annotation.CacheResolverthat is identical to the Spring’s CacheResolverinterface, except that JCache only supports a single cache. By default, a simple implementation retrieves the cache to use based on the name declared on the annotation. It should be noted that if no cache name is specified on the annotation, a default is automatically generated, check the javadoc of @CacheResult#cacheName()for more information.

CacheResolverinstances are retrieved by a CacheResolverFactory. It is possible to customize the factory per cache operation:

@CacheResult(cacheNames=
								"books",
								
									cacheResolverFactory=MyCacheResolverFactory.class)
								publicBook findBook(ISBN isbn)
[Note] Note

For all referenced classes, Spring tries to locate a bean with the given type. If more than one match exists, a new instance is created and can use the regular bean lifecycle callbacks such as dependency injection.

Keys are generated by a javax.cache.annotation.CacheKeyGeneratorthat serves the same purpose as Spring’s KeyGenerator. By default, all method arguments are taken into account unless at least one parameter is annotated with @CacheKey. This is similar to Spring’s custom key generation declaration. For instance these are identical operations, one using Spring’s abstraction and the other with JCache:

@Cacheable(cacheNames=
								"books",
								
									key="#isbn")
								publicBook findBook(ISBN isbn,
								booleancheckWarehouse,
								booleanincludeUsed)
								
									@CacheResult(cacheName="books")
								publicBook findBook(
								
									@CacheKeyISBN isbn,
								booleancheckWarehouse,
								booleanincludeUsed)

The CacheKeyResolverto use can also be specified on the operation, in a similar fashion as the CacheResolverFactory.

JCache can manage exceptions thrown by annotated methods: this can prevent an update of the cache but it can also cache the exception as an indicator of the failure instead of calling the method again. Let’s assume that InvalidIsbnNotFoundExceptionis thrown if the structure of the ISBN is invalid. This is a permanent failure, no book could ever be retrieved with such parameter. The following caches the exception so that further calls with the same, invalid ISBN, throws the cached exception directly instead of invoking the method again.

@CacheResult(cacheName=
								"books",
								
									exceptionCacheName="failures"
								
									cachedExceptions = InvalidIsbnNotFoundException.class)
								publicBook findBook(ISBN isbn)

36.4.2 Enabling JSR-107 support

Nothing specific needs to be done to enable the JSR-107 support alongside Spring’s declarative annotation support. Both @EnableCachingand the cache:annotation-drivenelement will enable automatically the JCache support if both the JSR-107 API and the spring-context-supportmodule are present in the classpath.

[Note] Note

Depending of your use case, the choice is basically yours. You can even mix and match services using the JSR-107 API and others using Spring’s own annotations. Be aware however that if these services are impacting the same caches, a consistent and identical key generation implementation should be used.

36.5 Declarative XML-based caching

If annotations are not an option (no access to the sources or no external code), one can use XML for declarative caching. So instead of annotating the methods for caching, one specifies the target method and the caching directives externally (similar to the declarative transaction management advice). The previous example can be translated into:

							<!-- the service we want to make cacheable -->
							<bean
							id=
							"bookService"
							class=
							"x.y.service.DefaultBookService"
							/>
							<!-- cache definitions -->
							<cache:advice
							id=
							"cacheAdvice"
							cache-manager=
							"cacheManager"
							>
							<cache:caching
							cache=
							"books"
							>
							<cache:cacheable
							method=
							"findBook"
							key=
							"#isbn"
							/>
							<cache:cache-evict
							method=
							"loadBooks"
							all-entries=
							"true"
							/>
							</cache:caching>
							</cache:advice>
							<!-- apply the cacheable behavior to all BookService interfaces -->
							<aop:config>
							<aop:advisor
							advice-ref=
							"cacheAdvice"
							pointcut=
							"execution(* x.y.BookService.*(..))"
							/>
							</aop:config>
							<!-- cache manager definition omitted -->

In the configuration above, the bookServiceis made cacheable. The caching semantics to apply are encapsulated in the cache:advicedefinition which instructs method findBooksto be used for putting data into the cache while method loadBooksfor evicting data. Both definitions are working against the bookscache.

The aop:configdefinition applies the cache advice to the appropriate points in the program by using the AspectJ pointcut expression (more information is available in Chapter 11, Aspect Oriented Programming with Spring ). In the example above, all methods from the BookServiceare considered and the cache advice applied to them.

The declarative XML caching supports all of the annotation-based model so moving between the two should be fairly easy - further more both can be used inside the same application. The XML based approach does not touch the target code however it is inherently more verbose; when dealing with classes with overloaded methods that are targeted for caching, identifying the proper methods does take an extra effort since the methodargument is not a good discriminator - in these cases, the AspectJ pointcut can be used to cherry pick the target methods and apply the appropriate caching functionality. However through XML, it is easier to apply a package/group/interface-wide caching (again due to the AspectJ pointcut) and to create template-like definitions (as we did in the example above by defining the target cache through the cache:definitions cacheattribute).

36.6 Configuring the cache storage

Out of the box, the cache abstraction provides several storage integration. To use them, one needs to simply declare an appropriate CacheManager- an entity that controls and manages Caches and can be used to retrieve these for storage.

36.6.1 JDK ConcurrentMap-based Cache

The JDK-based Cacheimplementation resides under org.springframework.cache.concurrentpackage. It allows one to use ConcurrentHashMapas a backing Cachestore.

								<!-- simple cache manager -->
								<bean
								id=
								"cacheManager"
								class=
								"org.springframework.cache.support.SimpleCacheManager"
								>
								<property
								name=
								"caches"
								>
								<set>
								<bean
								class=
								"org.springframework.cache.concurrent.ConcurrentMapCacheFactoryBean"
								p:name=
								"default"
								/>
								<bean
								class=
								"org.springframework.cache.concurrent.ConcurrentMapCacheFactoryBean"
								p:name=
								"books"
								/>
								</set>
								</property>
								</bean>

The snippet above uses the SimpleCacheManagerto create a CacheManagerfor the two nested ConcurrentMapCacheinstances named defaultand books. Note that the names are configured directly for each cache.

As the cache is created by the application, it is bound to its lifecycle, making it suitable for basic use cases, tests or simple applications. The cache scales well and is very fast but it does not provide any management or persistence capabilities nor eviction contracts.

36.6.2 Ehcache-based Cache

[Note] Note

Ehcache 3.x is fully JSR-107 compliant and no dedicated support is required for it.

The Ehcache 2.x implementation is located under org.springframework.cache.ehcachepackage. Again, to use it, one simply needs to declare the appropriate CacheManager:

								<bean
								id=
								"cacheManager"
								class=
								"org.springframework.cache.ehcache.EhCacheCacheManager"
								p:cache-manager-ref=
								"ehcache"
								/>
								<!-- EhCache library setup -->
								<bean
								id=
								"ehcache"
								class=
								"org.springframework.cache.ehcache.EhCacheManagerFactoryBean"
								p:config-location=
								"ehcache.xml"
								/>

This setup bootstraps the ehcache library inside Spring IoC (through the ehcachebean) which is then wired into the dedicated CacheManagerimplementation. Note the entire ehcache-specific configuration is read from ehcache.xml.

36.6.3 Caffeine Cache

Caffeine is a Java 8 rewrite of Guava’s cache and its implementation is located under org.springframework.cache.caffeinepackage and provides access to several features of Caffeine.

Configuring a CacheManagerthat creates the cache on demand is straightforward:

								<bean
								id=
								"cacheManager"
								class=
								"org.springframework.cache.caffeine.CaffeineCacheManager"
								/>

It is also possible to provide the caches to use explicitly. In that case, only those will be made available by the manager:

								<bean
								id=
								"cacheManager"
								class=
								"org.springframework.cache.caffeine.CaffeineCacheManager"
								>
								<property
								name=
								"caches"
								>
								<set>
								<value>default
								</value>
								<value>books
								</value>
								</set>
								</property>
								</bean>

The Caffeine CacheManageralso supports customs Caffeineand CacheLoader. See the Caffeine documentationfor more information about those.

36.6.4 Guava Cache

The Guava implementation is located under org.springframework.cache.guavapackage and provides access to several features of Guava.

Configuring a CacheManagerthat creates the cache on demand is straightforward:

								<bean
								id=
								"cacheManager"
								class=
								"org.springframework.cache.guava.GuavaCacheManager"
								/>

It is also possible to provide the caches to use explicitly. In that case, only those will be made available by the manager:

								<bean
								id=
								"cacheManager"
								class=
								"org.springframework.cache.guava.GuavaCacheManager"
								>
								<property
								name=
								"caches"
								>
								<set>
								<value>default
								</value>
								<value>books
								</value>
								</set>
								</property>
								</bean>

The Guava CacheManageralso supports customs CacheBuilderand CacheLoader. See the Guava documentationfor more information about those.

36.6.5 GemFire-based Cache

GemFire is a memory-oriented/disk-backed, elastically scalable, continuously available, active (with built-in pattern-based subscription notifications), globally replicated database and provides fully-featured edge caching. For further information on how to use GemFire as a CacheManager (and more), please refer to the Spring Data GemFire reference documentation.

36.6.6 JSR-107 Cache

JSR-107 compliant caches can also be used by Spring’s caching abstraction. The JCache implementation is located under org.springframework.cache.jcachepackage.

Again, to use it, one simply needs to declare the appropriate CacheManager:

								<bean
								id=
								"cacheManager"
								class=
								"org.springframework.cache.jcache.JCacheCacheManager"
								p:cache-manager-ref=
								"jCacheManager"
								/>
								<!-- JSR-107 cache manager setup -->
								<bean
								id=
								"jCacheManager"
								.../>

36.6.7 Dealing with caches without a backing store

Sometimes when switching environments or doing testing, one might have cache declarations without an actual backing cache configured. As this is an invalid configuration, at runtime an exception will be thrown since the caching infrastructure is unable to find a suitable store. In situations like this, rather then removing the cache declarations (which can prove tedious), one can wire in a simple, dummy cache that performs no caching - that is, forces the cached methods to be executed every time:

								<bean
								id=
								"cacheManager"
								class=
								"org.springframework.cache.support.CompositeCacheManager"
								>
								<property
								name=
								"cacheManagers"
								>
								<list>
								<ref
								bean=
								"jdkCache"
								/>
								<ref
								bean=
								"gemfireCache"
								/>
								</list>
								</property>
								<property
								name=
								"fallbackToNoOpCache"
								value=
								"true"
								/>
								</bean>

The CompositeCacheManagerabove chains multiple CacheManagers and additionally, through the fallbackToNoOpCacheflag, adds a no opcache that for all the definitions not handled by the configured cache managers. That is, every cache definition not found in either jdkCacheor gemfireCache(configured above) will be handled by the no op cache, which will not store any information causing the target method to be executed every time.

36.7 Plugging-in different back-end caches

Clearly there are plenty of caching products out there that can be used as a backing store. To plug them in, one needs to provide a CacheManagerand Cacheimplementation since unfortunately there is no available standard that we can use instead. This may sound harder than it is since in practice, the classes tend to be simple adapters that map the caching abstraction framework on top of the storage API as the ehcacheclasses can show. Most CacheManagerclasses can use the classes in org.springframework.cache.supportpackage, such as AbstractCacheManagerwhich takes care of the boiler-plate code leaving only the actual mappingto be completed. We hope that in time, the libraries that provide integration with Spring can fill in this small configuration gap.

36.8 How can I set the TTL/TTI/Eviction policy/XXX feature?

Directly through your cache provider. The cache abstraction is…​ well, an abstraction not a cache implementation. The solution you are using might support various data policies and different topologies which other solutions do not (take for example the JDK ConcurrentHashMap) - exposing that in the cache abstraction would be useless simply because there would no backing support. Such functionality should be controlled directly through the backing cache, when configuring it or through its native API.

Part VIII. Appendices

37. Migrating to Spring Framework 4.x

Migration guides for upgrading from previous releases of the Spring Framework are now provided as a Wiki page.

38. Spring Annotation Programming Model

Spring’s annotation programming model is documented in the Spring Framework Wiki.

39. Classic Spring Usage

This appendix discusses some classic Spring usage patterns as a reference for developers maintaining legacy Spring applications. These usage patterns no longer reflect the recommended way of using these features, and the current recommended usage is covered in the respective sections of the reference manual.

39.1 Classic ORM usage

This section documents the classic usage patterns that you might encounter in a legacy Spring application. For the currently recommended usage patterns, please refer to the ORMchapter.

39.1.1 Hibernate

For the currently recommended usage patterns for Hibernate see Section 20.3, “Hibernate”.

The HibernateTemplate

The basic programming model for templating looks as follows, for methods that can be part of any custom data access object or business service. There are no restrictions on the implementation of the surrounding object at all, it just needs to provide a Hibernate SessionFactory. It can get the latter from anywhere, but preferably as bean reference from a Spring IoC container - via a simple setSessionFactory(..)bean property setter. The following snippets show a DAO definition in a Spring container, referencing the above defined SessionFactory, and an example for a DAO method implementation.

									<beans>
									<bean
									id=
									"myProductDao"
									class=
									"product.ProductDaoImpl"
									>
									<property
									name=
									"sessionFactory"
									ref=
									"mySessionFactory"
									/>
									</bean>
									</beans>
									public
									classProductDaoImpl
									implementsProductDao {
									privateHibernateTemplate hibernateTemplate;
									public
									voidsetSessionFactory(SessionFactory sessionFactory) {
									this.hibernateTemplate =
									newHibernateTemplate(sessionFactory); }
									publicCollection loadProductsByCategory(String category)
									throwsDataAccessException {
									return
									this.hibernateTemplate.find(
									"from test.Product product where product.category=?", category); } }

The HibernateTemplateclass provides many methods that mirror the methods exposed on the Hibernate Sessioninterface, in addition to a number of convenience methods such as the one shown above. If you need access to the Sessionto invoke methods that are not exposed on the HibernateTemplate, you can always drop down to a callback-based approach like so.

									public
									classProductDaoImpl
									implementsProductDao {
									privateHibernateTemplate hibernateTemplate;
									public
									voidsetSessionFactory(SessionFactory sessionFactory) {
									this.hibernateTemplate =
									newHibernateTemplate(sessionFactory); }
									publicCollection loadProductsByCategory(
									finalString category)
									throwsDataAccessException {
									return
									this.hibernateTemplate.execute(
									newHibernateCallback() {
									publicObject doInHibernate(Session session) { Criteria criteria = session.createCriteria(Product.
									class); criteria.add(Expression.eq(
									"category", category)); criteria.setMaxResults(
									6);
									returncriteria.list(); } }; } }

A callback implementation effectively can be used for any Hibernate data access. HibernateTemplatewill ensure that Sessioninstances are properly opened and closed, and automatically participate in transactions. The template instances are thread-safe and reusable, they can thus be kept as instance variables of the surrounding class. For simple single step actions like a single find, load, saveOrUpdate, or delete call, HibernateTemplateoffers alternative convenience methods that can replace such one line callback implementations. Furthermore, Spring provides a convenient HibernateDaoSupportbase class that provides a setSessionFactory(..)method for receiving a SessionFactory, and getSessionFactory()and getHibernateTemplate()for use by subclasses. In combination, this allows for very simple DAO implementations for typical requirements:

									public
									classProductDaoImpl
									extendsHibernateDaoSupport
									implementsProductDao {
									publicCollection loadProductsByCategory(String category)
									throwsDataAccessException {
									return
									this.getHibernateTemplate().find(
									"from test.Product product where product.category=?", category); } }

Implementing Spring-based DAOs without callbacks

As alternative to using Spring’s HibernateTemplateto implement DAOs, data access code can also be written in a more traditional fashion, without wrapping the Hibernate access code in a callback, while still respecting and participating in Spring’s generic DataAccessExceptionhierarchy. The HibernateDaoSupportbase class offers methods to access the current transactional Sessionand to convert exceptions in such a scenario; similar methods are also available as static helpers on the SessionFactoryUtilsclass. Note that such code will usually pass falseas the value of the getSession(..)methods allowCreateargument, to enforce running within a transaction (which avoids the need to close the returned Session, as its lifecycle is managed by the transaction).

									public
									classHibernateProductDao
									extendsHibernateDaoSupport
									implementsProductDao {
									publicCollection loadProductsByCategory(String category)
									throwsDataAccessException, MyException { Session session = getSession(false);
									try{ Query query = session.createQuery(
									"from test.Product product where product.category=?"); query.setString(
									0, category); List result = query.list();
									if(result == null) {
									throw
									newMyException(
									"No search results."); }
									returnresult; }
									catch(HibernateException ex) {
									throwconvertHibernateAccessException(ex); } } }

The advantage of such direct Hibernate access code is that it allows anychecked application exception to be thrown within the data access code; contrast this to the HibernateTemplateclass which is restricted to throwing only unchecked exceptions within the callback. Note that you can often defer the corresponding checks and the throwing of application exceptions to after the callback, which still allows working with HibernateTemplate. In general, the HibernateTemplateclass' convenience methods are simpler and more convenient for many scenarios.

39.2 JMS Usage

One of the benefits of Spring’s JMS support is to shield the user from differences between the JMS 1.0.2 and 1.1 APIs. (For a description of the differences between the two APIs see sidebar on Domain Unification). Since it is now common to encounter only the JMS 1.1 API the use of classes that are based on the JMS 1.0.2 API has been deprecated in Spring 3.0. This section describes Spring JMS support for the JMS 1.0.2 deprecated classes.

Domain Unification

There are two major releases of the JMS specification, 1.0.2 and 1.1.

JMS 1.0.2 defined two types of messaging domains, point-to-point (Queues) and publish/subscribe (Topics). The 1.0.2 API reflected these two messaging domains by providing a parallel class hierarchy for each domain. As a result, a client application became domain specific in its use of the JMS API. JMS 1.1 introduced the concept of domain unification that minimized both the functional differences and client API differences between the two domains. As an example of a functional difference that was removed, if you use a JMS 1.1 provider you can transactionally consume a message from one domain and produce a message on the other using the same Session.

[Note] Note

The JMS 1.1 specification was released in April 2002 and incorporated as part of J2EE 1.4 in November 2003. As a result, common J2EE 1.3 application servers which are still in widespread use (such as BEA WebLogic 8.1 and IBM WebSphere 5.1) are based on JMS 1.0.2.

39.2.1 JmsTemplate

Located in the package org.springframework.jms.corethe class JmsTemplate102provides all of the features of the JmsTemplatedescribed the JMS chapter, but is based on the JMS 1.0.2 API instead of the JMS 1.1 API. As a consequence, if you are using JmsTemplate102 you need to set the boolean property pubSubDomainto configure the JmsTemplatewith knowledge of what JMS domain is being used. By default the value of this property is false, indicating that the point-to-point domain, Queues, will be used.

39.2.2 Asynchronous Message Reception

MessageListenerAdapter’sare used in conjunction with Spring’s message listener containersto support asynchronous message reception by exposing almost any class as a Message-driven POJO. If you are using the JMS 1.0.2 API, you will want to use the 1.0.2 specific classes such as MessageListenerAdapter102, SimpleMessageListenerContainer102, and DefaultMessageListenerContainer102. These classes provide the same functionality as the JMS 1.1 based counterparts but rely only on the JMS 1.0.2 API.

39.2.3 Connections

The ConnectionFactoryinterface is part of the JMS specification and serves as the entry point for working with JMS. Spring provides an implementation of the ConnectionFactoryinterface, SingleConnectionFactory102, based on the JMS 1.0.2 API that will return the same Connectionon all createConnection()calls and ignore calls to close(). You will need to set the boolean property pubSubDomainto indicate which messaging domain is used as SingleConnectionFactory102will always explicitly differentiate between a javax.jms.QueueConnectionand a javax.jmsTopicConnection.

39.2.4 Transaction Management

In a JMS 1.0.2 environment the class JmsTransactionManager102provides support for managing JMS transactions for a single Connection Factory. Please refer to the reference documentation on JMS Transaction Managementfor more information on this functionality.

40. Classic Spring AOP Usage

In this appendix we discuss the lower-level Spring AOP APIs and the AOP support used in Spring 1.2 applications. For new applications, we recommend the use of the Spring 2.0 AOP support described in the AOPchapter, but when working with existing applications, or when reading books and articles, you may come across Spring 1.2 style examples. Spring 2.0 is fully backwards compatible with Spring 1.2 and everything described in this appendix is fully supported in Spring 2.0.

40.1 Pointcut API in Spring

Let’s look at how Spring handles the crucial pointcut concept.

40.1.1 Concepts

Spring’s pointcut model enables pointcut reuse independent of advice types. It’s possible to target different advice using the same pointcut.

The org.springframework.aop.Pointcutinterface is the central interface, used to target advices to particular classes and methods. The complete interface is shown below:

								public
								interfacePointcut { ClassFilter getClassFilter(); MethodMatcher getMethodMatcher(); }

Splitting the Pointcutinterface into two parts allows reuse of class and method matching parts, and fine-grained composition operations (such as performing a "union" with another method matcher).

The ClassFilterinterface is used to restrict the pointcut to a given set of target classes. If the matches()method always returns true, all target classes will be matched:

								public
								interfaceClassFilter {
								booleanmatches(Class clazz); }

The MethodMatcherinterface is normally more important. The complete interface is shown below:

								public
								interfaceMethodMatcher {
								booleanmatches(Method m, Class targetClass);
								booleanisRuntime();
								booleanmatches(Method m, Class targetClass, Object[] args); }

The matches(Method, Class)method is used to test whether this pointcut will ever match a given method on a target class. This evaluation can be performed when an AOP proxy is created, to avoid the need for a test on every method invocation. If the 2-argument matches method returns true for a given method, and the isRuntime()method for the MethodMatcher returns true, the 3-argument matches method will be invoked on every method invocation. This enables a pointcut to look at the arguments passed to the method invocation immediately before the target advice is to execute.

Most MethodMatchers are static, meaning that their isRuntime()method returns false. In this case, the 3-argument matches method will never be invoked.

[Tip] Tip

If possible, try to make pointcuts static, allowing the AOP framework to cache the results of pointcut evaluation when an AOP proxy is created.

40.1.2 Operations on pointcuts

Spring supports operations on pointcuts: notably, unionand intersection.

  • Union means the methods that either pointcut matches.
  • Intersection means the methods that both pointcuts match.
  • Union is usually more useful.
  • Pointcuts can be composed using the static methods in the org.springframework.aop.support.Pointcutsclass, or using the ComposablePointcutclass in the same package. However, using AspectJ pointcut expressions is usually a simpler approach.

40.1.3 AspectJ expression pointcuts

Since 2.0, the most important type of pointcut used by Spring is org.springframework.aop.aspectj.AspectJExpressionPointcut. This is a pointcut that uses an AspectJ supplied library to parse an AspectJ pointcut expression string.

See the previous chapter for a discussion of supported AspectJ pointcut primitives.

40.1.4 Convenience pointcut implementations

Spring provides several convenient pointcut implementations. Some can be used out of the box; others are intended to be subclassed in application-specific pointcuts.

Static pointcuts

Static pointcuts are based on method and target class, and cannot take into account the method’s arguments. Static pointcuts are sufficient - and best- for most usages. It’s possible for Spring to evaluate a static pointcut only once, when a method is first invoked: after that, there is no need to evaluate the pointcut again with each method invocation.

Let’s consider some static pointcut implementations included with Spring.

Regular expression pointcuts

One obvious way to specify static pointcuts is regular expressions. Several AOP frameworks besides Spring make this possible. org.springframework.aop.support.Perl5RegexpMethodPointcutis a generic regular expression pointcut, using Perl 5 regular expression syntax. The Perl5RegexpMethodPointcutclass depends on Jakarta ORO for regular expression matching. Spring also provides the JdkRegexpMethodPointcutclass that uses the regular expression support in JDK 1.4+.

Using the Perl5RegexpMethodPointcutclass, you can provide a list of pattern Strings. If any of these is a match, the pointcut will evaluate to true. (So the result is effectively the union of these pointcuts.)

The usage is shown below:

										<bean
										id=
										"settersAndAbsquatulatePointcut"
										class=
										"org.springframework.aop.support.Perl5RegexpMethodPointcut"
										>
										<property
										name=
										"patterns"
										>
										<list>
										<value>.
										
											set.
										</value>
										<value>.*absquatulate
										</value>
										</list>
										</property>
										</bean>

Spring provides a convenience class, RegexpMethodPointcutAdvisor, that allows us to also reference an Advice (remember that an Advice can be an interceptor, before advice, throws advice etc.). Behind the scenes, Spring will use a JdkRegexpMethodPointcut. Using RegexpMethodPointcutAdvisorsimplifies wiring, as the one bean encapsulates both pointcut and advice, as shown below:

										<bean
										id=
										"settersAndAbsquatulateAdvisor"
										class=
										"org.springframework.aop.support.RegexpMethodPointcutAdvisor"
										>
										<property
										name=
										"advice"
										>
										<ref
										bean=
										"beanNameOfAopAllianceInterceptor"
										/>
										</property>
										<property
										name=
										"patterns"
										>
										<list>
										<value>.
										
											set.
										</value>
										<value>.*absquatulate
										</value>
										</list>
										</property>
										</bean>

RegexpMethodPointcutAdvisorcan be used with any Advice type.

Attribute-driven pointcuts

An important type of static pointcut is a metadata-drivenpointcut. This uses the values of metadata attributes: typically, source-level metadata.

Dynamic pointcuts

Dynamic pointcuts are costlier to evaluate than static pointcuts. They take into account method arguments, as well as static information. This means that they must be evaluated with every method invocation; the result cannot be cached, as arguments will vary.

The main example is the control flowpointcut.

Control flow pointcuts

Spring control flow pointcuts are conceptually similar to AspectJ cflowpointcuts, although less powerful. (There is currently no way to specify that a pointcut executes below a join point matched by another pointcut.) A control flow pointcut matches the current call stack. For example, it might fire if the join point was invoked by a method in the com.mycompany.webpackage, or by the SomeCallerclass. Control flow pointcuts are specified using the org.springframework.aop.support.ControlFlowPointcutclass.

[Note] Note

Control flow pointcuts are significantly more expensive to evaluate at runtime than even other dynamic pointcuts. In Java 1.4, the cost is about 5 times that of other dynamic pointcuts.

40.1.5 Pointcut superclasses

Spring provides useful pointcut superclasses to help you to implement your own pointcuts.

Because static pointcuts are most useful, you’ll probably subclass StaticMethodMatcherPointcut, as shown below. This requires implementing just one abstract method (although it’s possible to override other methods to customize behavior):

								classTestStaticPointcut
								extendsStaticMethodMatcherPointcut {
								public
								booleanmatches(Method m, Class targetClass) {
								// return true if custom criteria match} }

There are also superclasses for dynamic pointcuts.

You can use custom pointcuts with any advice type in Spring 1.0 RC2 and above.

40.1.6 Custom pointcuts

Because pointcuts in Spring AOP are Java classes, rather than language features (as in AspectJ) it’s possible to declare custom pointcuts, whether static or dynamic. Custom pointcuts in Spring can be arbitrarily complex. However, using the AspectJ pointcut expression language is recommended if possible.

[Note] Note

Later versions of Spring may offer support for "semantic pointcuts" as offered by JAC: for example, "all methods that change instance variables in the target object."

40.2 Advice API in Spring

Let’s now look at how Spring AOP handles advice.

40.2.1 Advice lifecycles

Each advice is a Spring bean. An advice instance can be shared across all advised objects, or unique to each advised object. This corresponds to per-classor per-instanceadvice.

Per-class advice is used most often. It is appropriate for generic advice such as transaction advisors. These do not depend on the state of the proxied object or add new state; they merely act on the method and arguments.

Per-instance advice is appropriate for introductions, to support mixins. In this case, the advice adds state to the proxied object.

It’s possible to use a mix of shared and per-instance advice in the same AOP proxy.

40.2.2 Advice types in Spring

Spring provides several advice types out of the box, and is extensible to support arbitrary advice types. Let us look at the basic concepts and standard advice types.

Interception around advice

The most fundamental advice type in Spring is interception around advice.

Spring is compliant with the AOP Alliance interface for around advice using method interception. MethodInterceptors implementing around advice should implement the following interface:

									public
									interfaceMethodInterceptor
									extendsInterceptor { Object invoke(MethodInvocation invocation)
									throwsThrowable; }

The MethodInvocationargument to the invoke()method exposes the method being invoked; the target join point; the AOP proxy; and the arguments to the method. The invoke()method should return the invocation’s result: the return value of the join point.

A simple MethodInterceptorimplementation looks as follows:

									public
									classDebugInterceptor
									implementsMethodInterceptor {
									publicObject invoke(MethodInvocation invocation)
									throwsThrowable { System.out.println(
									"Before: invocation=["+ invocation +
									"]"); Object rval = invocation.proceed(); System.out.println(
									"Invocation returned");
									returnrval; } }

Note the call to the MethodInvocation’s proceed()method. This proceeds down the interceptor chain towards the join point. Most interceptors will invoke this method, and return its return value. However, a MethodInterceptor, like any around advice, can return a different value or throw an exception rather than invoke the proceed method. However, you don’t want to do this without good reason!

[Note] Note

MethodInterceptors offer interoperability with other AOP Alliance-compliant AOP implementations. The other advice types discussed in the remainder of this section implement common AOP concepts, but in a Spring-specific way. While there is an advantage in using the most specific advice type, stick with MethodInterceptor around advice if you are likely to want to run the aspect in another AOP framework. Note that pointcuts are not currently interoperable between frameworks, and the AOP Alliance does not currently define pointcut interfaces.

Before advice

A simpler advice type is a before advice. This does not need a MethodInvocationobject, since it will only be called before entering the method.

The main advantage of a before advice is that there is no need to invoke the proceed()method, and therefore no possibility of inadvertently failing to proceed down the interceptor chain.

The MethodBeforeAdviceinterface is shown below. (Spring’s API design would allow for field before advice, although the usual objects apply to field interception and it’s unlikely that Spring will ever implement it).

									public
									interfaceMethodBeforeAdvice
									extendsBeforeAdvice {
									voidbefore(Method m, Object[] args, Object target)
									throwsThrowable; }

Note the return type is void. Before advice can insert custom behavior before the join point executes, but cannot change the return value. If a before advice throws an exception, this will abort further execution of the interceptor chain. The exception will propagate back up the interceptor chain. If it is unchecked, or on the signature of the invoked method, it will be passed directly to the client; otherwise it will be wrapped in an unchecked exception by the AOP proxy.

An example of a before advice in Spring, which counts all method invocations:

									public
									classCountingBeforeAdvice
									implementsMethodBeforeAdvice {
									private
									intcount;
									public
									voidbefore(Method m, Object[] args, Object target)
									throwsThrowable { ++count; }
									public
									intgetCount() {
									returncount; } }
[Tip] Tip

Before advice can be used with any pointcut.

Throws advice

Throws adviceis invoked after the return of the join point if the join point threw an exception. Spring offers typed throws advice. Note that this means that the org.springframework.aop.ThrowsAdviceinterface does not contain any methods: It is a tag interface identifying that the given object implements one or more typed throws advice methods. These should be in the form of:

afterThrowing([Method, args, target], subclassOfThrowable)

Only the last argument is required. The method signatures may have either one or four arguments, depending on whether the advice method is interested in the method and arguments. The following classes are examples of throws advice.

The advice below is invoked if a RemoteExceptionis thrown (including subclasses):

									public
									classRemoteThrowsAdvice
									implementsThrowsAdvice {
									public
									voidafterThrowing(RemoteException ex)
									throwsThrowable {
									// Do something with remote exception} }

The following advice is invoked if a ServletExceptionis thrown. Unlike the above advice, it declares 4 arguments, so that it has access to the invoked method, method arguments and target object:

									public
									classServletThrowsAdviceWithArguments
									implementsThrowsAdvice {
									public
									voidafterThrowing(Method m, Object[] args, Object target, ServletException ex) {
									// Do something with all arguments} }

The final example illustrates how these two methods could be used in a single class, which handles both RemoteExceptionand ServletException. Any number of throws advice methods can be combined in a single class.

									public
									static
									classCombinedThrowsAdvice
									implementsThrowsAdvice {
									public
									voidafterThrowing(RemoteException ex)
									throwsThrowable {
									// Do something with remote exception}
									public
									voidafterThrowing(Method m, Object[] args, Object target, ServletException ex) {
									// Do something with all arguments} }

Note:If a throws-advice method throws an exception itself, it will override the original exception (i.e. change the exception thrown to the user). The overriding exception will typically be a RuntimeException; this is compatible with any method signature. However, if a throws-advice method throws a checked exception, it will have to match the declared exceptions of the target method and is hence to some degree coupled to specific target method signatures. Do not throw an undeclared checked exception that is incompatible with the target method’s signature!

[Tip] Tip

Throws advice can be used with any pointcut.

After Returning advice

An after returning advice in Spring must implement the org.springframework.aop.AfterReturningAdviceinterface, shown below:

									public
									interfaceAfterReturningAdvice
									extendsAdvice {
									voidafterReturning(Object returnValue, Method m, Object[] args, Object target)
									throwsThrowable; }

An after returning advice has access to the return value (which it cannot modify), invoked method, methods arguments and target.

The following after returning advice counts all successful method invocations that have not thrown exceptions:

									public
									classCountingAfterReturningAdvice
									implementsAfterReturningAdvice {
									private
									intcount;
									public
									voidafterReturning(Object returnValue, Method m, Object[] args, Object target)
									throwsThrowable { ++count; }
									public
									intgetCount() {
									returncount; } }

This advice doesn’t change the execution path. If it throws an exception, this will be thrown up the interceptor chain instead of the return value.

[Tip] Tip

After returning advice can be used with any pointcut.

Introduction advice

Spring treats introduction advice as a special kind of interception advice.

Introduction requires an IntroductionAdvisor, and an IntroductionInterceptor, implementing the following interface:

									public
									interfaceIntroductionInterceptor
									extendsMethodInterceptor {
									booleanimplementsInterface(Class intf); }

The invoke()method inherited from the AOP Alliance MethodInterceptorinterface must implement the introduction: that is, if the invoked method is on an introduced interface, the introduction interceptor is responsible for handling the method call - it cannot invoke proceed().

Introduction advice cannot be used with any pointcut, as it applies only at class, rather than method, level. You can only use introduction advice with the IntroductionAdvisor, which has the following methods:

									public
									interfaceIntroductionAdvisor
									extendsAdvisor, IntroductionInfo { ClassFilter getClassFilter();
									voidvalidateInterfaces()
									throwsIllegalArgumentException; }
									public
									interfaceIntroductionInfo { Class[] getInterfaces(); }

There is no MethodMatcher, and hence no Pointcut, associated with introduction advice. Only class filtering is logical.

The getInterfaces()method returns the interfaces introduced by this advisor.

The validateInterfaces()method is used internally to see whether or not the introduced interfaces can be implemented by the configured IntroductionInterceptor.

Let’s look at a simple example from the Spring test suite. Let’s suppose we want to introduce the following interface to one or more objects:

									public
									interfaceLockable {
									voidlock();
									voidunlock();
									booleanlocked(); }

This illustrates a mixin. We want to be able to cast advised objects to Lockable, whatever their type, and call lock and unlock methods. If we call the lock() method, we want all setter methods to throw a LockedException. Thus we can add an aspect that provides the ability to make objects immutable, without them having any knowledge of it: a good example of AOP.

Firstly, we’ll need an IntroductionInterceptorthat does the heavy lifting. In this case, we extend the org.springframework.aop.support.DelegatingIntroductionInterceptorconvenience class. We could implement IntroductionInterceptor directly, but using DelegatingIntroductionInterceptoris best for most cases.

The DelegatingIntroductionInterceptoris designed to delegate an introduction to an actual implementation of the introduced interface(s), concealing the use of interception to do so. The delegate can be set to any object using a constructor argument; the default delegate (when the no-arg constructor is used) is this. Thus in the example below, the delegate is the LockMixinsubclass of DelegatingIntroductionInterceptor. Given a delegate (by default itself), a DelegatingIntroductionInterceptorinstance looks for all interfaces implemented by the delegate (other than IntroductionInterceptor), and will support introductions against any of them. It’s possible for subclasses such as LockMixinto call the suppressInterface(Class intf)method to suppress interfaces that should not be exposed. However, no matter how many interfaces an IntroductionInterceptoris prepared to support, the IntroductionAdvisorused will control which interfaces are actually exposed. An introduced interface will conceal any implementation of the same interface by the target.

Thus LockMixin subclasses DelegatingIntroductionInterceptorand implements Lockable itself. The superclass automatically picks up that Lockable can be supported for introduction, so we don’t need to specify that. We could introduce any number of interfaces in this way.

Note the use of the lockedinstance variable. This effectively adds additional state to that held in the target object.

									public
									classLockMixin
									extendsDelegatingIntroductionInterceptor
									implementsLockable {
									private
									booleanlocked;
									public
									voidlock() {
									this.locked = true; }
									public
									voidunlock() {
									this.locked = false; }
									public
									booleanlocked() {
									return
									this.locked; }
									publicObject invoke(MethodInvocation invocation)
									throwsThrowable {
									if(locked() && invocation.getMethod().getName().indexOf(
									"set") ==
									0) {
									throw
									newLockedException(); }
									return
									super.invoke(invocation); } }

Often it isn’t necessary to override the invoke()method: the DelegatingIntroductionInterceptorimplementation - which calls the delegate method if the method is introduced, otherwise proceeds towards the join point - is usually sufficient. In the present case, we need to add a check: no setter method can be invoked if in locked mode.

The introduction advisor required is simple. All it needs to do is hold a distinct LockMixininstance, and specify the introduced interfaces - in this case, just Lockable. A more complex example might take a reference to the introduction interceptor (which would be defined as a prototype): in this case, there’s no configuration relevant for a LockMixin, so we simply create it using new.

									public
									classLockMixinAdvisor
									extendsDefaultIntroductionAdvisor {
									publicLockMixinAdvisor() {
									super(
									newLockMixin(), Lockable.
									class); } }

We can apply this advisor very simply: it requires no configuration. (However, it isnecessary: It’s impossible to use an IntroductionInterceptorwithout an IntroductionAdvisor.) As usual with introductions, the advisor must be per-instance, as it is stateful. We need a different instance of LockMixinAdvisor, and hence LockMixin, for each advised object. The advisor comprises part of the advised object’s state.

We can apply this advisor programmatically, using the Advised.addAdvisor()method, or (the recommended way) in XML configuration, like any other advisor. All proxy creation choices discussed below, including "auto proxy creators," correctly handle introductions and stateful mixins.

40.3 Advisor API in Spring

In Spring, an Advisor is an aspect that contains just a single advice object associated with a pointcut expression.

Apart from the special case of introductions, any advisor can be used with any advice. org.springframework.aop.support.DefaultPointcutAdvisoris the most commonly used advisor class. For example, it can be used with a MethodInterceptor, BeforeAdviceor ThrowsAdvice.

It is possible to mix advisor and advice types in Spring in the same AOP proxy. For example, you could use a interception around advice, throws advice and before advice in one proxy configuration: Spring will automatically create the necessary interceptor chain.

40.4 Using the ProxyFactoryBean to create AOP proxies

If you’re using the Spring IoC container (an ApplicationContext or BeanFactory) for your business objects - and you should be! - you will want to use one of Spring’s AOP FactoryBeans. (Remember that a factory bean introduces a layer of indirection, enabling it to create objects of a different type.)

[Note] Note

The Spring 2.0 AOP support also uses factory beans under the covers.

The basic way to create an AOP proxy in Spring is to use the org.springframework.aop.framework.ProxyFactoryBean. This gives complete control over the pointcuts and advice that will apply, and their ordering. However, there are simpler options that are preferable if you don’t need such control.

40.4.1 Basics

The ProxyFactoryBean, like other Spring FactoryBeanimplementations, introduces a level of indirection. If you define a ProxyFactoryBeanwith name foo, what objects referencing foosee is not the ProxyFactoryBeaninstance itself, but an object created by the ProxyFactoryBean’s implementation of the `getObject()method. This method will create an AOP proxy wrapping a target object.

One of the most important benefits of using a ProxyFactoryBeanor another IoC-aware class to create AOP proxies, is that it means that advices and pointcuts can also be managed by IoC. This is a powerful feature, enabling certain approaches that are hard to achieve with other AOP frameworks. For example, an advice may itself reference application objects (besides the target, which should be available in any AOP framework), benefiting from all the pluggability provided by Dependency Injection.

40.4.2 JavaBean properties

In common with most FactoryBeanimplementations provided with Spring, the ProxyFactoryBeanclass is itself a JavaBean. Its properties are used to:

Some key properties are inherited from org.springframework.aop.framework.ProxyConfig(the superclass for all AOP proxy factories in Spring). These key properties include:

  • proxyTargetClass: trueif the target class is to be proxied, rather than the target class' interfaces. If this property value is set to true, then CGLIB proxies will be created (but see also below Section 12.5.3, “JDK- and CGLIB-based proxies”).
  • optimize: controls whether or not aggressive optimizations are applied to proxies created via CGLIB. One should not blithely use this setting unless one fully understands how the relevant AOP proxy handles optimization. This is currently used only for CGLIB proxies; it has no effect with JDK dynamic proxies.
  • frozen: if a proxy configuration is frozen, then changes to the configuration are no longer allowed. This is useful both as a slight optimization and for those cases when you don’t want callers to be able to manipulate the proxy (via the Advisedinterface) after the proxy has been created. The default value of this property is false, so changes such as adding additional advice are allowed.
  • exposeProxy: determines whether or not the current proxy should be exposed in a ThreadLocalso that it can be accessed by the target. If a target needs to obtain the proxy and the exposeProxyproperty is set to true, the target can use the AopContext.currentProxy()method.
  • aopProxyFactory: the implementation of AopProxyFactoryto use. Offers a way of customizing whether to use dynamic proxies, CGLIB or any other proxy strategy. The default implementation will choose dynamic proxies or CGLIB appropriately. There should be no need to use this property; it is intended to allow the addition of new proxy types in Spring 1.1.

Other properties specific to ProxyFactoryBeaninclude:

  • proxyInterfaces: array of String interface names. If this isn’t supplied, a CGLIB proxy for the target class will be used (but see also below Section 12.5.3, “JDK- and CGLIB-based proxies”).
  • interceptorNames: String array of Advisor, interceptor or other advice names to apply. Ordering is significant, on a first come-first served basis. That is to say that the first interceptor in the list will be the first to be able to intercept the invocation.

The names are bean names in the current factory, including bean names from ancestor factories. You can’t mention bean references here since doing so would result in the ProxyFactoryBeanignoring the singleton setting of the advice.

You can append an interceptor name with an asterisk ( *). This will result in the application of all advisor beans with names starting with the part before the asterisk to be applied. An example of using this feature can be found in Section 12.5.6, “Using 'global' advisors”.

  • singleton: whether or not the factory should return a single object, no matter how often the getObject()method is called. Several FactoryBeanimplementations offer such a method. The default value is true. If you want to use stateful advice - for example, for stateful mixins - use prototype advices along with a singleton value of false.

40.4.3 JDK- and CGLIB-based proxies

This section serves as the definitive documentation on how the ProxyFactoryBeanchooses to create one of either a JDK- and CGLIB-based proxy for a particular target object (that is to be proxied).

[Note] Note

The behavior of the ProxyFactoryBeanwith regard to creating JDK- or CGLIB-based proxies changed between versions 1.2.x and 2.0 of Spring. The ProxyFactoryBeannow exhibits similar semantics with regard to auto-detecting interfaces as those of the TransactionProxyFactoryBeanclass.

If the class of a target object that is to be proxied (hereafter simply referred to as the target class) doesn’t implement any interfaces, then a CGLIB-based proxy will be created. This is the easiest scenario, because JDK proxies are interface based, and no interfaces means JDK proxying isn’t even possible. One simply plugs in the target bean, and specifies the list of interceptors via the interceptorNamesproperty. Note that a CGLIB-based proxy will be created even if the proxyTargetClassproperty of the ProxyFactoryBeanhas been set to false. (Obviously this makes no sense, and is best removed from the bean definition because it is at best redundant, and at worst confusing.)

If the target class implements one (or more) interfaces, then the type of proxy that is created depends on the configuration of the ProxyFactoryBean.

If the proxyTargetClassproperty of the ProxyFactoryBeanhas been set to true, then a CGLIB-based proxy will be created. This makes sense, and is in keeping with the principle of least surprise. Even if the proxyInterfacesproperty of the ProxyFactoryBeanhas been set to one or more fully qualified interface names, the fact that the proxyTargetClassproperty is set to true willcause CGLIB-based proxying to be in effect.

If the proxyInterfacesproperty of the ProxyFactoryBeanhas been set to one or more fully qualified interface names, then a JDK-based proxy will be created. The created proxy will implement all of the interfaces that were specified in the proxyInterfacesproperty; if the target class happens to implement a whole lot more interfaces than those specified in the proxyInterfacesproperty, that is all well and good but those additional interfaces will not be implemented by the returned proxy.

If the proxyInterfacesproperty of the ProxyFactoryBeanhas notbeen set, but the target class does implement one (or more)interfaces, then the ProxyFactoryBeanwill auto-detect the fact that the target class does actually implement at least one interface, and a JDK-based proxy will be created. The interfaces that are actually proxied will be allof the interfaces that the target class implements; in effect, this is the same as simply supplying a list of each and every interface that the target class implements to the proxyInterfacesproperty. However, it is significantly less work, and less prone to typos.

40.4.4 Proxying interfaces

Let’s look at a simple example of ProxyFactoryBeanin action. This example involves:

  • A target beanthat will be proxied. This is the "personTarget" bean definition in the example below.
  • An Advisor and an Interceptor used to provide advice.
  • An AOP proxy bean definition specifying the target object (the personTarget bean) and the interfaces to proxy, along with the advices to apply.
								<bean
								id=
								"personTarget"
								class=
								"com.mycompany.PersonImpl"
								>
								<property
								name=
								"name"
								>
								<value>Tony
								</value>
								</property>
								<property
								name=
								"age"
								>
								<value>51
								</value>
								</property>
								</bean>
								<bean
								id=
								"myAdvisor"
								class=
								"com.mycompany.MyAdvisor"
								>
								<property
								name=
								"someProperty"
								>
								<value>Custom string property value
								</value>
								</property>
								</bean>
								<bean
								id=
								"debugInterceptor"
								class=
								"org.springframework.aop.interceptor.DebugInterceptor"
								>
								</bean>
								<bean
								id=
								"person"
								class=
								"org.springframework.aop.framework.ProxyFactoryBean"
								>
								<property
								name=
								"proxyInterfaces"
								>
								<value>com.mycompany.Person
								</value>
								</property>
								<property
								name=
								"target"
								>
								<ref
								bean=
								"personTarget"
								/>
								</property>
								<property
								name=
								"interceptorNames"
								>
								<list>
								<value>myAdvisor
								</value>
								<value>debugInterceptor
								</value>
								</list>
								</property>
								</bean>

Note that the interceptorNamesproperty takes a list of String: the bean names of the interceptor or advisors in the current factory. Advisors, interceptors, before, after returning and throws advice objects can be used. The ordering of advisors is significant.

[Note] Note

You might be wondering why the list doesn’t hold bean references. The reason for this is that if the ProxyFactoryBean’s singleton property is set to false, it must be able to return independent proxy instances. If any of the advisors is itself a prototype, an independent instance would need to be returned, so it’s necessary to be able to obtain an instance of the prototype from the factory; holding a reference isn’t sufficient.

The "person" bean definition above can be used in place of a Person implementation, as follows:

Person person = (Person) factory.getBean(
								"person");

Other beans in the same IoC context can express a strongly typed dependency on it, as with an ordinary Java object:

								<bean
								id=
								"personUser"
								class=
								"com.mycompany.PersonUser"
								>
								<property
								name=
								"person"
								>
								<ref
								bean=
								"person"
								/>
								</property>
								</bean>

The PersonUserclass in this example would expose a property of type Person. As far as it’s concerned, the AOP proxy can be used transparently in place of a "real" person implementation. However, its class would be a dynamic proxy class. It would be possible to cast it to the Advisedinterface (discussed below).

It’s possible to conceal the distinction between target and proxy using an anonymous inner bean, as follows. Only the ProxyFactoryBeandefinition is different; the advice is included only for completeness:

								<bean
								id=
								"myAdvisor"
								class=
								"com.mycompany.MyAdvisor"
								>
								<property
								name=
								"someProperty"
								>
								<value>Custom string property value
								</value>
								</property>
								</bean>
								<bean
								id=
								"debugInterceptor"
								class=
								"org.springframework.aop.interceptor.DebugInterceptor"
								/>
								<bean
								id=
								"person"
								class=
								"org.springframework.aop.framework.ProxyFactoryBean"
								>
								<property
								name=
								"proxyInterfaces"
								>
								<value>com.mycompany.Person
								</value>
								</property>
								<!-- Use inner bean, not local reference to target -->
								<property
								name=
								"target"
								>
								<bean
								class=
								"com.mycompany.PersonImpl"
								>
								<property
								name=
								"name"
								>
								<value>Tony
								</value>
								</property>
								<property
								name=
								"age"
								>
								<value>51
								</value>
								</property>
								</bean>
								</property>
								<property
								name=
								"interceptorNames"
								>
								<list>
								<value>myAdvisor
								</value>
								<value>debugInterceptor
								</value>
								</list>
								</property>
								</bean>

This has the advantage that there’s only one object of type Person: useful if we want to prevent users of the application context from obtaining a reference to the un-advised object, or need to avoid any ambiguity with Spring IoC autowiring. There’s also arguably an advantage in that the ProxyFactoryBean definition is self-contained. However, there are times when being able to obtain the un-advised target from the factory might actually be an advantage: for example, in certain test scenarios.

40.4.5 Proxying classes

What if you need to proxy a class, rather than one or more interfaces?

Imagine that in our example above, there was no Personinterface: we needed to advise a class called Personthat didn’t implement any business interface. In this case, you can configure Spring to use CGLIB proxying, rather than dynamic proxies. Simply set the proxyTargetClassproperty on the ProxyFactoryBean above to true. While it’s best to program to interfaces, rather than classes, the ability to advise classes that don’t implement interfaces can be useful when working with legacy code. (In general, Spring isn’t prescriptive. While it makes it easy to apply good practices, it avoids forcing a particular approach.)

If you want to, you can force the use of CGLIB in any case, even if you do have interfaces.

CGLIB proxying works by generating a subclass of the target class at runtime. Spring configures this generated subclass to delegate method calls to the original target: the subclass is used to implement the Decoratorpattern, weaving in the advice.

CGLIB proxying should generally be transparent to users. However, there are some issues to consider:

  • Finalmethods can’t be advised, as they can’t be overridden.
  • As of Spring 3.2 it is no longer required to add CGLIB to your project classpath. CGLIB classes have been repackaged under org.springframework and included directly in the spring-core JAR. This is both for user convenience as well as to avoid potential conflicts with other projects that have dependence on a differing version of CGLIB.

There’s little performance difference between CGLIB proxying and dynamic proxies. As of Spring 1.0, dynamic proxies are slightly faster. However, this may change in the future. Performance should not be a decisive consideration in this case.

40.4.6 Using 'global' advisors

By appending an asterisk to an interceptor name, all advisors with bean names matching the part before the asterisk, will be added to the advisor chain. This can come in handy if you need to add a standard set of 'global' advisors:

								<bean
								id=
								"proxy"
								class=
								"org.springframework.aop.framework.ProxyFactoryBean"
								>
								<property
								name=
								"target"
								ref=
								"service"
								/>
								<property
								name=
								"interceptorNames"
								>
								<list>
								<value>global*
								</value>
								</list>
								</property>
								</bean>
								<bean
								id=
								"global_debug"
								class=
								"org.springframework.aop.interceptor.DebugInterceptor"
								/>
								<bean
								id=
								"global_performance"
								class=
								"org.springframework.aop.interceptor.PerformanceMonitorInterceptor"
								/>

40.5 Concise proxy definitions

Especially when defining transactional proxies, you may end up with many similar proxy definitions. The use of parent and child bean definitions, along with inner bean definitions, can result in much cleaner and more concise proxy definitions.

First a parent, template, bean definition is created for the proxy:

							<bean
							id=
							"txProxyTemplate"
							abstract=
							"true"
							class=
							"org.springframework.transaction.interceptor.TransactionProxyFactoryBean"
							>
							<property
							name=
							"transactionManager"
							ref=
							"transactionManager"
							/>
							<property
							name=
							"transactionAttributes"
							>
							<props>
							<prop
							key=
							"*"
							>PROPAGATION_REQUIRED
							</prop>
							</props>
							</property>
							</bean>

This will never be instantiated itself, so may actually be incomplete. Then each proxy which needs to be created is just a child bean definition, which wraps the target of the proxy as an inner bean definition, since the target will never be used on its own anyway.

							<bean
							id=
							"myService"
							parent=
							"txProxyTemplate"
							>
							<property
							name=
							"target"
							>
							<bean
							class=
							"org.springframework.samples.MyServiceImpl"
							>
							</bean>
							</property>
							</bean>

It is of course possible to override properties from the parent template, such as in this case, the transaction propagation settings:

							<bean
							id=
							"mySpecialService"
							parent=
							"txProxyTemplate"
							>
							<property
							name=
							"target"
							>
							<bean
							class=
							"org.springframework.samples.MySpecialServiceImpl"
							>
							</bean>
							</property>
							<property
							name=
							"transactionAttributes"
							>
							<props>
							<prop
							key=
							"get*"
							>PROPAGATION_REQUIRED,readOnly
							</prop>
							<prop
							key=
							"find*"
							>PROPAGATION_REQUIRED,readOnly
							</prop>
							<prop
							key=
							"load*"
							>PROPAGATION_REQUIRED,readOnly
							</prop>
							<prop
							key=
							"store*"
							>PROPAGATION_REQUIRED
							</prop>
							</props>
							</property>
							</bean>

Note that in the example above, we have explicitly marked the parent bean definition as abstractby using the abstractattribute, as described previously, so that it may not actually ever be instantiated. Application contexts (but not simple bean factories) will by default pre-instantiate all singletons. It is therefore important (at least for singleton beans) that if you have a (parent) bean definition which you intend to use only as a template, and this definition specifies a class, you must make sure to set the abstractattribute to true, otherwise the application context will actually try to pre-instantiate it.

40.6 Creating AOP proxies programmatically with the ProxyFactory

It’s easy to create AOP proxies programmatically using Spring. This enables you to use Spring AOP without dependency on Spring IoC.

The following listing shows creation of a proxy for a target object, with one interceptor and one advisor. The interfaces implemented by the target object will automatically be proxied:

ProxyFactory factory =
							newProxyFactory(myBusinessInterfaceImpl); factory.addInterceptor(myMethodInterceptor); factory.addAdvisor(myAdvisor); MyBusinessInterface tb = (MyBusinessInterface) factory.getProxy();

The first step is to construct an object of type org.springframework.aop.framework.ProxyFactory. You can create this with a target object, as in the above example, or specify the interfaces to be proxied in an alternate constructor.

You can add interceptors or advisors, and manipulate them for the life of the ProxyFactory. If you add an IntroductionInterceptionAroundAdvisor you can cause the proxy to implement additional interfaces.

There are also convenience methods on ProxyFactory (inherited from AdvisedSupport) which allow you to add other advice types such as before and throws advice. AdvisedSupport is the superclass of both ProxyFactory and ProxyFactoryBean.

[Tip] Tip

Integrating AOP proxy creation with the IoC framework is best practice in most applications. We recommend that you externalize configuration from Java code with AOP, as in general.

40.7 Manipulating advised objects

However you create AOP proxies, you can manipulate them using the org.springframework.aop.framework.Advisedinterface. Any AOP proxy can be cast to this interface, whichever other interfaces it implements. This interface includes the following methods:

Advisor[] getAdvisors();
							voidaddAdvice(Advice advice)
							throwsAopConfigException;
							voidaddAdvice(
							intpos, Advice advice)
							throwsAopConfigException;
							voidaddAdvisor(Advisor advisor)
							throwsAopConfigException;
							voidaddAdvisor(
							intpos, Advisor advisor)
							throwsAopConfigException;
							intindexOf(Advisor advisor);
							booleanremoveAdvisor(Advisor advisor)
							throwsAopConfigException;
							voidremoveAdvisor(
							intindex)
							throwsAopConfigException;
							booleanreplaceAdvisor(Advisor a, Advisor b)
							throwsAopConfigException;
							booleanisFrozen();

The getAdvisors()method will return an Advisor for every advisor, interceptor or other advice type that has been added to the factory. If you added an Advisor, the returned advisor at this index will be the object that you added. If you added an interceptor or other advice type, Spring will have wrapped this in an advisor with a pointcut that always returns true. Thus if you added a MethodInterceptor, the advisor returned for this index will be an DefaultPointcutAdvisorreturning your MethodInterceptorand a pointcut that matches all classes and methods.

The addAdvisor()methods can be used to add any Advisor. Usually the advisor holding pointcut and advice will be the generic DefaultPointcutAdvisor, which can be used with any advice or pointcut (but not for introductions).

By default, it’s possible to add or remove advisors or interceptors even once a proxy has been created. The only restriction is that it’s impossible to add or remove an introduction advisor, as existing proxies from the factory will not show the interface change. (You can obtain a new proxy from the factory to avoid this problem.)

A simple example of casting an AOP proxy to the Advisedinterface and examining and manipulating its advice:

Advised advised = (Advised) myObject; Advisor[] advisors = advised.getAdvisors();
							intoldAdvisorCount = advisors.length; System.out.println(oldAdvisorCount +
							" advisors");
							// Add an advice like an interceptor without a pointcut
							// Will match all proxied methods
							// Can use for interceptors, before, after returning or throws adviceadvised.addAdvice(
							newDebugInterceptor());
							// Add selective advice using a pointcutadvised.addAdvisor(
							newDefaultPointcutAdvisor(mySpecialPointcut, myAdvice)); assertEquals(
							"Added two advisors", oldAdvisorCount +
							2, advised.getAdvisors().length);
[Note] Note

It’s questionable whether it’s advisable (no pun intended) to modify advice on a business object in production, although there are no doubt legitimate usage cases. However, it can be very useful in development: for example, in tests. I have sometimes found it very useful to be able to add test code in the form of an interceptor or other advice, getting inside a method invocation I want to test. (For example, the advice can get inside a transaction created for that method: for example, to run SQL to check that a database was correctly updated, before marking the transaction for roll back.)

Depending on how you created the proxy, you can usually set a frozenflag, in which case the Advised isFrozen()method will return true, and any attempts to modify advice through addition or removal will result in an AopConfigException. The ability to freeze the state of an advised object is useful in some cases, for example, to prevent calling code removing a security interceptor. It may also be used in Spring 1.1 to allow aggressive optimization if runtime advice modification is known not to be required.

40.8 Using the "autoproxy" facility

So far we’ve considered explicit creation of AOP proxies using a ProxyFactoryBeanor similar factory bean.

Spring also allows us to use "autoproxy" bean definitions, which can automatically proxy selected bean definitions. This is built on Spring "bean post processor" infrastructure, which enables modification of any bean definition as the container loads.

In this model, you set up some special bean definitions in your XML bean definition file to configure the auto proxy infrastructure. This allows you just to declare the targets eligible for autoproxying: you don’t need to use ProxyFactoryBean.

There are two ways to do this:

  • Using an autoproxy creator that refers to specific beans in the current context.
  • A special case of autoproxy creation that deserves to be considered separately; autoproxy creation driven by source-level metadata attributes.

40.8.1 Autoproxy bean definitions

The org.springframework.aop.framework.autoproxypackage provides the following standard autoproxy creators.

BeanNameAutoProxyCreator

The BeanNameAutoProxyCreatorclass is a BeanPostProcessorthat automatically creates AOP proxies for beans with names matching literal values or wildcards.

									<bean
									class=
									"org.springframework.aop.framework.autoproxy.BeanNameAutoProxyCreator"
									>
									<property
									name=
									"beanNames"
									>
									<value>jdk*,onlyJdk
									</value>
									</property>
									<property
									name=
									"interceptorNames"
									>
									<list>
									<value>myInterceptor
									</value>
									</list>
									</property>
									</bean>

As with ProxyFactoryBean, there is an interceptorNamesproperty rather than a list of interceptors, to allow correct behavior for prototype advisors. Named "interceptors" can be advisors or any advice type.

As with auto proxying in general, the main point of using BeanNameAutoProxyCreatoris to apply the same configuration consistently to multiple objects, with minimal volume of configuration. It is a popular choice for applying declarative transactions to multiple objects.

Bean definitions whose names match, such as "jdkMyBean" and "onlyJdk" in the above example, are plain old bean definitions with the target class. An AOP proxy will be created automatically by the BeanNameAutoProxyCreator. The same advice will be applied to all matching beans. Note that if advisors are used (rather than the interceptor in the above example), the pointcuts may apply differently to different beans.

DefaultAdvisorAutoProxyCreator

A more general and extremely powerful auto proxy creator is DefaultAdvisorAutoProxyCreator. This will automagically apply eligible advisors in the current context, without the need to include specific bean names in the autoproxy advisor’s bean definition. It offers the same merit of consistent configuration and avoidance of duplication as BeanNameAutoProxyCreator.

Using this mechanism involves:

  • Specifying a DefaultAdvisorAutoProxyCreatorbean definition.
  • Specifying any number of Advisors in the same or related contexts. Note that these mustbe Advisors, not just interceptors or other advices. This is necessary because there must be a pointcut to evaluate, to check the eligibility of each advice to candidate bean definitions.

The DefaultAdvisorAutoProxyCreatorwill automatically evaluate the pointcut contained in each advisor, to see what (if any) advice it should apply to each business object (such as "businessObject1" and "businessObject2" in the example).

This means that any number of advisors can be applied automatically to each business object. If no pointcut in any of the advisors matches any method in a business object, the object will not be proxied. As bean definitions are added for new business objects, they will automatically be proxied if necessary.

Autoproxying in general has the advantage of making it impossible for callers or dependencies to obtain an un-advised object. Calling getBean("businessObject1") on this ApplicationContext will return an AOP proxy, not the target business object. (The "inner bean" idiom shown earlier also offers this benefit.)

									<bean
									class=
									"org.springframework.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator"
									/>
									<bean
									class=
									"org.springframework.transaction.interceptor.TransactionAttributeSourceAdvisor"
									>
									<property
									name=
									"transactionInterceptor"
									ref=
									"transactionInterceptor"
									/>
									</bean>
									<bean
									id=
									"customAdvisor"
									class=
									"com.mycompany.MyAdvisor"
									/>
									<bean
									id=
									"businessObject1"
									class=
									"com.mycompany.BusinessObject1"
									>
									<!-- Properties omitted -->
									</bean>
									<bean
									id=
									"businessObject2"
									class=
									"com.mycompany.BusinessObject2"
									/>

The DefaultAdvisorAutoProxyCreatoris very useful if you want to apply the same advice consistently to many business objects. Once the infrastructure definitions are in place, you can simply add new business objects without including specific proxy configuration. You can also drop in additional aspects very easily - for example, tracing or performance monitoring aspects - with minimal change to configuration.

The DefaultAdvisorAutoProxyCreator offers support for filtering (using a naming convention so that only certain advisors are evaluated, allowing use of multiple, differently configured, AdvisorAutoProxyCreators in the same factory) and ordering. Advisors can implement the org.springframework.core.Orderedinterface to ensure correct ordering if this is an issue. The TransactionAttributeSourceAdvisor used in the above example has a configurable order value; the default setting is unordered.

AbstractAdvisorAutoProxyCreator

This is the superclass of DefaultAdvisorAutoProxyCreator. You can create your own autoproxy creators by subclassing this class, in the unlikely event that advisor definitions offer insufficient customization to the behavior of the framework DefaultAdvisorAutoProxyCreator.

40.8.2 Using metadata-driven auto-proxying

A particularly important type of autoproxying is driven by metadata. This produces a similar programming model to .NET ServicedComponents. Instead of using XML deployment descriptors as in EJB, configuration for transaction management and other enterprise services is held in source-level attributes.

In this case, you use the DefaultAdvisorAutoProxyCreator, in combination with Advisors that understand metadata attributes. The metadata specifics are held in the pointcut part of the candidate advisors, rather than in the autoproxy creation class itself.

This is really a special case of the DefaultAdvisorAutoProxyCreator, but deserves consideration on its own. (The metadata-aware code is in the pointcuts contained in the advisors, not the AOP framework itself.)

The /attributesdirectory of the JPetStore sample application shows the use of attribute-driven autoproxying. In this case, there’s no need to use the TransactionProxyFactoryBean. Simply defining transactional attributes on business objects is sufficient, because of the use of metadata-aware pointcuts. The bean definitions include the following code, in /WEB-INF/declarativeServices.xml. Note that this is generic, and can be used outside the JPetStore:

								<bean
								class=
								"org.springframework.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator"
								/>
								<bean
								class=
								"org.springframework.transaction.interceptor.TransactionAttributeSourceAdvisor"
								>
								<property
								name=
								"transactionInterceptor"
								ref=
								"transactionInterceptor"
								/>
								</bean>
								<bean
								id=
								"transactionInterceptor"
								class=
								"org.springframework.transaction.interceptor.TransactionInterceptor"
								>
								<property
								name=
								"transactionManager"
								ref=
								"transactionManager"
								/>
								<property
								name=
								"transactionAttributeSource"
								>
								<bean
								class=
								"org.springframework.transaction.interceptor.AttributesTransactionAttributeSource"
								>
								<property
								name=
								"attributes"
								ref=
								"attributes"
								/>
								</bean>
								</property>
								</bean>
								<bean
								id=
								"attributes"
								class=
								"org.springframework.metadata.commons.CommonsAttributes"
								/>

The DefaultAdvisorAutoProxyCreatorbean definition (the name is not significant, hence it can even be omitted) will pick up all eligible pointcuts in the current application context. In this case, the "transactionAdvisor" bean definition, of type TransactionAttributeSourceAdvisor, will apply to classes or methods carrying a transaction attribute. The TransactionAttributeSourceAdvisor depends on a TransactionInterceptor, via constructor dependency. The example resolves this via autowiring. The AttributesTransactionAttributeSourcedepends on an implementation of the org.springframework.metadata.Attributesinterface. In this fragment, the "attributes" bean satisfies this, using the Jakarta Commons Attributes API to obtain attribute information. (The application code must have been compiled using the Commons Attributes compilation task.)

The /annotationdirectory of the JPetStore sample application contains an analogous example for auto-proxying driven by JDK 1.5+ annotations. The following configuration enables automatic detection of Spring’s Transactionalannotation, leading to implicit proxies for beans containing that annotation:

								<bean
								class=
								"org.springframework.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator"
								/>
								<bean
								class=
								"org.springframework.transaction.interceptor.TransactionAttributeSourceAdvisor"
								>
								<property
								name=
								"transactionInterceptor"
								ref=
								"transactionInterceptor"
								/>
								</bean>
								<bean
								id=
								"transactionInterceptor"
								class=
								"org.springframework.transaction.interceptor.TransactionInterceptor"
								>
								<property
								name=
								"transactionManager"
								ref=
								"transactionManager"
								/>
								<property
								name=
								"transactionAttributeSource"
								>
								<bean
								class=
								"org.springframework.transaction.annotation.AnnotationTransactionAttributeSource"
								/>
								</property>
								</bean>

The TransactionInterceptordefined here depends on a PlatformTransactionManagerdefinition, which is not included in this generic file (although it could be) because it will be specific to the application’s transaction requirements (typically JTA, as in this example, or Hibernate, JDO or JDBC):

								<bean
								id=
								"transactionManager"
								class=
								"org.springframework.transaction.jta.JtaTransactionManager"
								/>
[Tip] Tip

If you require only declarative transaction management, using these generic XML definitions will result in Spring automatically proxying all classes or methods with transaction attributes. You won’t need to work directly with AOP, and the programming model is similar to that of .NET ServicedComponents.

This mechanism is extensible. It’s possible to do autoproxying based on custom attributes. You need to:

  • Define your custom attribute.
  • Specify an Advisor with the necessary advice, including a pointcut that is triggered by the presence of the custom attribute on a class or method. You may be able to use an existing advice, merely implementing a static pointcut that picks up the custom attribute.

It’s possible for such advisors to be unique to each advised class (for example, mixins): they simply need to be defined as prototype, rather than singleton, bean definitions. For example, the LockMixinintroduction interceptor from the Spring test suite, shown above, could be used in conjunction with an attribute-driven pointcut to target a mixin, as shown here. We use the generic DefaultPointcutAdvisor, configured using JavaBean properties:

								<bean
								id=
								"lockMixin"
								class=
								"org.springframework.aop.LockMixin"
								scope=
								"prototype"
								/>
								<bean
								id=
								"lockableAdvisor"
								class=
								"org.springframework.aop.support.DefaultPointcutAdvisor"
								scope=
								"prototype"
								>
								<property
								name=
								"pointcut"
								ref=
								"myAttributeAwarePointcut"
								/>
								<property
								name=
								"advice"
								ref=
								"lockMixin"
								/>
								</bean>
								<bean
								id=
								"anyBean"
								class=
								"anyclass"
								...

If the attribute aware pointcut matches any methods in the anyBeanor other bean definitions, the mixin will be applied. Note that both lockMixinand lockableAdvisordefinitions are prototypes. The myAttributeAwarePointcutpointcut can be a singleton definition, as it doesn’t hold state for individual advised objects.

40.9 Using TargetSources

Spring offers the concept of a TargetSource, expressed in the org.springframework.aop.TargetSourceinterface. This interface is responsible for returning the "target object" implementing the join point. The TargetSourceimplementation is asked for a target instance each time the AOP proxy handles a method invocation.

Developers using Spring AOP don’t normally need to work directly with TargetSources, but this provides a powerful means of supporting pooling, hot swappable and other sophisticated targets. For example, a pooling TargetSource can return a different target instance for each invocation, using a pool to manage instances.

If you do not specify a TargetSource, a default implementation is used that wraps a local object. The same target is returned for each invocation (as you would expect).

Let’s look at the standard target sources provided with Spring, and how you can use them.

[Tip] Tip

When using a custom target source, your target will usually need to be a prototype rather than a singleton bean definition. This allows Spring to create a new target instance when required.

40.9.1 Hot swappable target sources

The org.springframework.aop.target.HotSwappableTargetSourceexists to allow the target of an AOP proxy to be switched while allowing callers to keep their references to it.

Changing the target source’s target takes effect immediately. The HotSwappableTargetSourceis threadsafe.

You can change the target via the swap()method on HotSwappableTargetSource as follows:

HotSwappableTargetSource swapper = (HotSwappableTargetSource) beanFactory.getBean(
								"swapper"); Object oldTarget = swapper.swap(newTarget);

The XML definitions required look as follows:

								<bean
								id=
								"initialTarget"
								class=
								"mycompany.OldTarget"
								/>
								<bean
								id=
								"swapper"
								class=
								"org.springframework.aop.target.HotSwappableTargetSource"
								>
								<constructor-arg
								ref=
								"initialTarget"
								/>
								</bean>
								<bean
								id=
								"swappable"
								class=
								"org.springframework.aop.framework.ProxyFactoryBean"
								>
								<property
								name=
								"targetSource"
								ref=
								"swapper"
								/>
								</bean>

The above swap()call changes the target of the swappable bean. Clients who hold a reference to that bean will be unaware of the change, but will immediately start hitting the new target.

Although this example doesn’t add any advice - and it’s not necessary to add advice to use a TargetSource- of course any TargetSourcecan be used in conjunction with arbitrary advice.

40.9.2 Pooling target sources

Using a pooling target source provides a similar programming model to stateless session EJBs, in which a pool of identical instances is maintained, with method invocations going to free objects in the pool.

A crucial difference between Spring pooling and SLSB pooling is that Spring pooling can be applied to any POJO. As with Spring in general, this service can be applied in a non-invasive way.

Spring provides out-of-the-box support for Commons Pool 2.2, which provides a fairly efficient pooling implementation. You’ll need the commons-pool Jar on your application’s classpath to use this feature. It’s also possible to subclass org.springframework.aop.target.AbstractPoolingTargetSourceto support any other pooling API.

[Note] Note

Commons Pool 1.5+ is also supported but deprecated as of Spring Framework 4.2.

Sample configuration is shown below:

								<bean
								id=
								"businessObjectTarget"
								class=
								"com.mycompany.MyBusinessObject"
								scope=
								"prototype"
								>... properties omitted
								</bean>
								<bean
								id=
								"poolTargetSource"
								class=
								"org.springframework.aop.target.CommonsPool2TargetSource"
								>
								<property
								name=
								"targetBeanName"
								value=
								"businessObjectTarget"
								/>
								<property
								name=
								"maxSize"
								value=
								"25"
								/>
								</bean>
								<bean
								id=
								"businessObject"
								class=
								"org.springframework.aop.framework.ProxyFactoryBean"
								>
								<property
								name=
								"targetSource"
								ref=
								"poolTargetSource"
								/>
								<property
								name=
								"interceptorNames"
								value=
								"myInterceptor"
								/>
								</bean>

Note that the target object - "businessObjectTarget" in the example - mustbe a prototype. This allows the PoolingTargetSourceimplementation to create new instances of the target to grow the pool as necessary. See the Javadoc for AbstractPoolingTargetSourceand the concrete subclass you wish to use for information about its properties: "maxSize" is the most basic, and always guaranteed to be present.

In this case, "myInterceptor" is the name of an interceptor that would need to be defined in the same IoC context. However, it isn’t necessary to specify interceptors to use pooling. If you want only pooling, and no other advice, don’t set the interceptorNames property at all.

It’s possible to configure Spring so as to be able to cast any pooled object to the org.springframework.aop.target.PoolingConfiginterface, which exposes information about the configuration and current size of the pool through an introduction. You’ll need to define an advisor like this:

								<bean
								id=
								"poolConfigAdvisor"
								class=
								"org.springframework.beans.factory.config.MethodInvokingFactoryBean"
								>
								<property
								name=
								"targetObject"
								ref=
								"poolTargetSource"
								/>
								<property
								name=
								"targetMethod"
								value=
								"getPoolingConfigMixin"
								/>
								</bean>

This advisor is obtained by calling a convenience method on the AbstractPoolingTargetSourceclass, hence the use of MethodInvokingFactoryBean. This advisor’s name ("poolConfigAdvisor" here) must be in the list of interceptors names in the ProxyFactoryBean exposing the pooled object.

The cast will look as follows:

PoolingConfig conf = (PoolingConfig) beanFactory.getBean(
								"businessObject"); System.out.println(
								"Max pool size is "+ conf.getMaxSize());
[Note] Note

Pooling stateless service objects is not usually necessary. We don’t believe it should be the default choice, as most stateless objects are naturally thread safe, and instance pooling is problematic if resources are cached.

Simpler pooling is available using autoproxying. It’s possible to set the TargetSources used by any autoproxy creator.

40.9.3 Prototype target sources

Setting up a "prototype" target source is similar to a pooling TargetSource. In this case, a new instance of the target will be created on every method invocation. Although the cost of creating a new object isn’t high in a modern JVM, the cost of wiring up the new object (satisfying its IoC dependencies) may be more expensive. Thus you shouldn’t use this approach without very good reason.

To do this, you could modify the poolTargetSourcedefinition shown above as follows. (I’ve also changed the name, for clarity.)

								<bean
								id=
								"prototypeTargetSource"
								class=
								"org.springframework.aop.target.PrototypeTargetSource"
								>
								<property
								name=
								"targetBeanName"
								ref=
								"businessObjectTarget"
								/>
								</bean>

There’s only one property: the name of the target bean. Inheritance is used in the TargetSource implementations to ensure consistent naming. As with the pooling target source, the target bean must be a prototype bean definition.

40.9.4 ThreadLocal target sources

ThreadLocaltarget sources are useful if you need an object to be created for each incoming request (per thread that is). The concept of a ThreadLocalprovide a JDK-wide facility to transparently store resource alongside a thread. Setting up a ThreadLocalTargetSourceis pretty much the same as was explained for the other types of target source:

								<bean
								id=
								"threadlocalTargetSource"
								class=
								"org.springframework.aop.target.ThreadLocalTargetSource"
								>
								<property
								name=
								"targetBeanName"
								value=
								"businessObjectTarget"
								/>
								</bean>
[Note] Note

ThreadLocals come with serious issues (potentially resulting in memory leaks) when incorrectly using them in a multi-threaded and multi-classloader environments. One should always consider wrapping a threadlocal in some other class and never directly use the ThreadLocalitself (except of course in the wrapper class). Also, one should always remember to correctly set and unset (where the latter simply involved a call to ThreadLocal.set(null)) the resource local to the thread. Unsetting should be done in any case since not unsetting it might result in problematic behavior. Spring’s ThreadLocal support does this for you and should always be considered in favor of using ThreadLocals without other proper handling code.

40.10 Defining new Advice types

Spring AOP is designed to be extensible. While the interception implementation strategy is presently used internally, it is possible to support arbitrary advice types in addition to the out-of-the-box interception around advice, before, throws advice and after returning advice.

The org.springframework.aop.framework.adapterpackage is an SPI package allowing support for new custom advice types to be added without changing the core framework. The only constraint on a custom Advicetype is that it must implement the org.aopalliance.aop.Advicetag interface.

Please refer to the org.springframework.aop.framework.adapterpackage’s Javadocs for further information.

40.11 Further resources

Please refer to the Spring sample applications for further examples of Spring AOP:

  • The JPetStore’s default configuration illustrates the use of the TransactionProxyFactoryBeanfor declarative transaction management.
  • The /attributesdirectory of the JPetStore illustrates the use of attribute-driven declarative transaction management.

41. XML Schema-based configuration

41.1 Introduction

This appendix details the XML Schema-based configuration introduced in Spring 2.0 and enhanced and extended in Spring 2.5 and 3.0.

DTD support?

Authoring Spring configuration files using the older DTD style is still fully supported.

Nothing will break if you forego the use of the new XML Schema-based approach to authoring Spring XML configuration files. All that you lose out on is the opportunity to have more succinct and clearer configuration. Regardless of whether the XML configuration is DTD- or Schema-based, in the end it all boils down to the same object model in the container (namely one or more BeanDefinitioninstances).

The central motivation for moving to XML Schema based configuration files was to make Spring XML configuration easier. The 'classic' <bean/>-based approach is good, but its generic-nature comes with a price in terms of configuration overhead.

From the Spring IoC containers point-of-view, everythingis a bean. That’s great news for the Spring IoC container, because if everything is a bean then everything can be treated in the exact same fashion. The same, however, is not true from a developer’s point-of-view. The objects defined in a Spring XML configuration file are not all generic, vanilla beans. Usually, each bean requires some degree of specific configuration.

Spring 2.0’s new XML Schema-based configuration addresses this issue. The <bean/>element is still present, and if you wanted to, you could continue to write the exact samestyle of Spring XML configuration using only <bean/>elements. The new XML Schema-based configuration does, however, make Spring XML configuration files substantially clearer to read. In addition, it allows you to express the intent of a bean definition.

The key thing to remember is that the new custom tags work best for infrastructure or integration beans: for example, AOP, collections, transactions, integration with 3rd-party frameworks such as Mule, etc., while the existing bean tags are best suited to application-specific beans, such as DAOs, service layer objects, validators, etc.

The examples included below will hopefully convince you that the inclusion of XML Schema support in Spring 2.0 was a good idea. The reception in the community has been encouraging; also, please note the fact that this new configuration mechanism is totally customisable and extensible. This means you can write your own domain-specific configuration tags that would better represent your application’s domain; the process involved in doing so is covered in the appendix entitled Chapter 42, Extensible XML authoring .

41.2 XML Schema-based configuration

41.2.1 Referencing the schemas

To switch over from the DTD-style to the new XML Schema-style, you need to make the following change.

								<?xml version="1.0" encoding="UTF-8"?>
								<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN 2.0//EN" "http://www.springframework.org/dtd/spring-beans-2.0.dtd">
								<beans>
								<!-- bean definitions here -->
								</beans>

The equivalent file in the XML Schema-style would be…​

								<?xml version="1.0" encoding="UTF-8"?>
								<beans
								xmlns=
								"http://www.springframework.org/schema/beans"
								xmlns:xsi=
								"http://www.w3.org/2001/XMLSchema-instance"
								xsi:schemaLocation=
								" http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd"
								>
								<!-- bean definitions here -->
								</beans>
[Note] Note

The 'xsi:schemaLocation'fragment is not actually required, but can be included to reference a local copy of a schema (which can be useful during development).

The above Spring XML configuration fragment is boilerplate that you can copy and paste (!) and then plug <bean/>definitions into like you have always done. However, the entire point of switching over is to take advantage of the new Spring 2.0 XML tags since they make configuration easier. The section entitled Section 41.2.2, “the util schema”demonstrates how you can start immediately by using some of the more common utility tags.

The rest of this chapter is devoted to showing examples of the new Spring XML Schema based configuration, with at least one example for every new tag. The format follows a before and after style, with a beforesnippet of XML showing the old (but still 100% legal and supported) style, followed immediately by an afterexample showing the equivalent in the new XML Schema-based style.

41.2.2 the util schema

First up is coverage of the utiltags. As the name implies, the utiltags deal with common, utilityconfiguration issues, such as configuring collections, referencing constants, and suchlike.

To use the tags in the utilschema, you need to have the following preamble at the top of your Spring XML configuration file; the text in the snippet below references the correct schema so that the tags in the utilnamespace are available to you.

								<?xml version="1.0" encoding="UTF-8"?>
								<beans
								xmlns=
								"http://www.springframework.org/schema/beans"
								xmlns:xsi=
								"http://www.w3.org/2001/XMLSchema-instance"
								
									xmlns:util="http://www.springframework.org/schema/util"xsi:schemaLocation=" http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
								
									http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util.xsd">
								<!-- bean definitions here -->
								</beans>

<util:constant/>

Before…​

									<bean
									id=
									"..."
									class=
									"..."
									>
									<property
									name=
									"isolation"
									>
									<bean
									id=
									"java.sql.Connection.TRANSACTION_SERIALIZABLE"
									class=
									"org.springframework.beans.factory.config.FieldRetrievingFactoryBean"
									/>
									</property>
									</bean>

The above configuration uses a Spring FactoryBeanimplementation, the FieldRetrievingFactoryBean, to set the value of the isolationproperty on a bean to the value of the java.sql.Connection.TRANSACTION_SERIALIZABLEconstant. This is all well and good, but it is a tad verbose and (unnecessarily) exposes Spring’s internal plumbing to the end user.

The following XML Schema-based version is more concise and clearly expresses the developer’s intent ( 'inject this constant value'), and it just reads better.

									<bean
									id=
									"..."
									class=
									"..."
									>
									<property
									name=
									"isolation"
									>
									<util:constant
									static-field=
									"java.sql.Connection.TRANSACTION_SERIALIZABLE"
									/>
									</property>
									</bean>
Setting a bean property or constructor arg from a field value

FieldRetrievingFactoryBeanis a FactoryBeanwhich retrieves a staticor non-static field value. It is typically used for retrieving public static finalconstants, which may then be used to set a property value or constructor arg for another bean.

Find below an example which shows how a staticfield is exposed, by using the staticFieldproperty:

										<bean
										id=
										"myField"
										class=
										"org.springframework.beans.factory.config.FieldRetrievingFactoryBean"
										>
										<property
										name=
										"staticField"
										value=
										"java.sql.Connection.TRANSACTION_SERIALIZABLE"
										/>
										</bean>

There is also a convenience usage form where the staticfield is specified as the bean name:

										<bean
										id=
										"java.sql.Connection.TRANSACTION_SERIALIZABLE"
										class=
										"org.springframework.beans.factory.config.FieldRetrievingFactoryBean"
										/>

This does mean that there is no longer any choice in what the bean id is (so any other bean that refers to it will also have to use this longer name), but this form is very concise to define, and very convenient to use as an inner bean since the id doesn’t have to be specified for the bean reference:

										<bean
										id=
										"..."
										class=
										"..."
										>
										<property
										name=
										"isolation"
										>
										<bean
										id=
										"java.sql.Connection.TRANSACTION_SERIALIZABLE"
										class=
										"org.springframework.beans.factory.config.FieldRetrievingFactoryBean"
										/>
										</property>
										</bean>

It is also possible to access a non-static (instance) field of another bean, as described in the API documentation for the FieldRetrievingFactoryBeanclass.

Injecting enum values into beans as either property or constructor arguments is very easy to do in Spring, in that you don’t actually have to doanything or know anything about the Spring internals (or even about classes such as the FieldRetrievingFactoryBean). Let’s look at an example to see how easy injecting an enum value is; consider this JDK 5 enum:

										packagejavax.persistence;
										publicenum PersistenceContextType { TRANSACTION, EXTENDED }

Now consider a setter of type PersistenceContextType:

										packageexample;
										public
										classClient {
										privatePersistenceContextType persistenceContextType;
										public
										voidsetPersistenceContextType(PersistenceContextType type) {
										this.persistenceContextType = type; } }
  1. and the corresponding bean definition:
										<bean
										class=
										"example.Client"
										>
										<property
										name=
										"persistenceContextType"
										value=
										"TRANSACTION"
										/>
										</bean>

This works for classic type-safe emulated enums (on JDK 1.4 and JDK 1.3) as well; Spring will automatically attempt to match the string property value to a constant on the enum class.

<util:property-path/>

Before…​

									<!-- target bean to be referenced by name -->
									<bean
									id=
									"testBean"
									class=
									"org.springframework.beans.TestBean"
									scope=
									"prototype"
									>
									<property
									name=
									"age"
									value=
									"10"
									/>
									<property
									name=
									"spouse"
									>
									<bean
									class=
									"org.springframework.beans.TestBean"
									>
									<property
									name=
									"age"
									value=
									"11"
									/>
									</bean>
									</property>
									</bean>
									<!-- will result in 10, which is the value of property 'age' of bean 'testBean' -->
									<bean
									id=
									"testBean.age"
									class=
									"org.springframework.beans.factory.config.PropertyPathFactoryBean"
									/>

The above configuration uses a Spring FactoryBeanimplementation, the PropertyPathFactoryBean, to create a bean (of type int) called testBean.agethat has a value equal to the ageproperty of the testBeanbean.

After…​

									<!-- target bean to be referenced by name -->
									<bean
									id=
									"testBean"
									class=
									"org.springframework.beans.TestBean"
									scope=
									"prototype"
									>
									<property
									name=
									"age"
									value=
									"10"
									/>
									<property
									name=
									"spouse"
									>
									<bean
									class=
									"org.springframework.beans.TestBean"
									>
									<property
									name=
									"age"
									value=
									"11"
									/>
									</bean>
									</property>
									</bean>
									<!-- will result in 10, which is the value of property 'age' of bean 'testBean' -->
									<util:property-path
									id=
									"name"
									path=
									"testBean.age"
									/>

The value of the pathattribute of the <property-path/>tag follows the form beanName.beanProperty.

Using <util:property-path/> to set a bean property or constructor-argument

PropertyPathFactoryBeanis a FactoryBeanthat evaluates a property path on a given target object. The target object can be specified directly or via a bean name. This value may then be used in another bean definition as a property value or constructor argument.

Here’s an example where a path is used against another bean, by name:

// target bean to be referenced by name
										<bean
										id=
										"person"
										class=
										"org.springframework.beans.TestBean"
										scope=
										"prototype"
										>
										<property
										name=
										"age"
										value=
										"10"
										/>
										<property
										name=
										"spouse"
										>
										<bean
										class=
										"org.springframework.beans.TestBean"
										>
										<property
										name=
										"age"
										value=
										"11"
										/>
										</bean>
										</property>
										</bean>// will result in 11, which is the value of property 'spouse.age' of bean 'person'
										<bean
										id=
										"theAge"
										class=
										"org.springframework.beans.factory.config.PropertyPathFactoryBean"
										>
										<property
										name=
										"targetBeanName"
										value=
										"person"
										/>
										<property
										name=
										"propertyPath"
										value=
										"spouse.age"
										/>
										</bean>

In this example, a path is evaluated against an inner bean:

										<!-- will result in 12, which is the value of property 'age' of the inner bean -->
										<bean
										id=
										"theAge"
										class=
										"org.springframework.beans.factory.config.PropertyPathFactoryBean"
										>
										<property
										name=
										"targetObject"
										>
										<bean
										class=
										"org.springframework.beans.TestBean"
										>
										<property
										name=
										"age"
										value=
										"12"
										/>
										</bean>
										</property>
										<property
										name=
										"propertyPath"
										value=
										"age"
										/>
										</bean>

There is also a shortcut form, where the bean name is the property path.

										<!-- will result in 10, which is the value of property 'age' of bean 'person' -->
										<bean
										id=
										"person.age"
										class=
										"org.springframework.beans.factory.config.PropertyPathFactoryBean"
										/>

This form does mean that there is no choice in the name of the bean. Any reference to it will also have to use the same id, which is the path. Of course, if used as an inner bean, there is no need to refer to it at all:

										<bean
										id=
										"..."
										class=
										"..."
										>
										<property
										name=
										"age"
										>
										<bean
										id=
										"person.age"
										class=
										"org.springframework.beans.factory.config.PropertyPathFactoryBean"
										/>
										</property>
										</bean>

The result type may be specifically set in the actual definition. This is not necessary for most use cases, but can be of use for some. Please see the Javadocs for more info on this feature.

<util:properties/>

Before…​

									<!-- creates a java.util.Properties instance with values loaded from the supplied location -->
									<bean
									id=
									"jdbcConfiguration"
									class=
									"org.springframework.beans.factory.config.PropertiesFactoryBean"
									>
									<property
									name=
									"location"
									value=
									"classpath:com/foo/jdbc-production.properties"
									/>
									</bean>

The above configuration uses a Spring FactoryBeanimplementation, the PropertiesFactoryBean, to instantiate a java.util.Propertiesinstance with values loaded from the supplied Resourcelocation).

After…​

									<!-- creates a java.util.Properties instance with values loaded from the supplied location -->
									<util:properties
									id=
									"jdbcConfiguration"
									location=
									"classpath:com/foo/jdbc-production.properties"
									/>

<util:list/>

Before…​

									<!-- creates a java.util.List instance with values loaded from the supplied 'sourceList' -->
									<bean
									id=
									"emails"
									class=
									"org.springframework.beans.factory.config.ListFactoryBean"
									>
									<property
									name=
									"sourceList"
									>
									<list>
									<value>pechorin@hero.org
									</value>
									<value>raskolnikov@slums.org
									</value>
									<value>stavrogin@gov.org
									</value>
									<value>porfiry@gov.org
									</value>
									</list>
									</property>
									</bean>

The above configuration uses a Spring FactoryBeanimplementation, the ListFactoryBean, to create a java.util.Listinstance initialized with values taken from the supplied sourceList.

After…​

									<!-- creates a java.util.List instance with the supplied values -->
									<util:list
									id=
									"emails"
									>
									<value>pechorin@hero.org
									</value>
									<value>raskolnikov@slums.org
									</value>
									<value>stavrogin@gov.org
									</value>
									<value>porfiry@gov.org
									</value>
									</util:list>

You can also explicitly control the exact type of Listthat will be instantiated and populated via the use of the list-classattribute on the <util:list/>element. For example, if we really need a java.util.LinkedListto be instantiated, we could use the following configuration:

									<util:list
									id=
									"emails"
									list-class=
									"java.util.LinkedList"
									>
									<value>jackshaftoe@vagabond.org
									</value>
									<value>eliza@thinkingmanscrumpet.org
									</value>
									<value>vanhoek@pirate.org
									</value>
									<value>d'Arcachon@nemesis.org
									</value>
									</util:list>

If no list-classattribute is supplied, a Listimplementation will be chosen by the container.

<util:map/>

Before…​

									<!-- creates a java.util.Map instance with values loaded from the supplied 'sourceMap' -->
									<bean
									id=
									"emails"
									class=
									"org.springframework.beans.factory.config.MapFactoryBean"
									>
									<property
									name=
									"sourceMap"
									>
									<map>
									<entry
									key=
									"pechorin"
									value=
									"pechorin@hero.org"
									/>
									<entry
									key=
									"raskolnikov"
									value=
									"raskolnikov@slums.org"
									/>
									<entry
									key=
									"stavrogin"
									value=
									"stavrogin@gov.org"
									/>
									<entry
									key=
									"porfiry"
									value=
									"porfiry@gov.org"
									/>
									</map>
									</property>
									</bean>

The above configuration uses a Spring FactoryBeanimplementation, the MapFactoryBean, to create a java.util.Mapinstance initialized with key-value pairs taken from the supplied 'sourceMap'.

After…​

									<!-- creates a java.util.Map instance with the supplied key-value pairs -->
									<util:map
									id=
									"emails"
									>
									<entry
									key=
									"pechorin"
									value=
									"pechorin@hero.org"
									/>
									<entry
									key=
									"raskolnikov"
									value=
									"raskolnikov@slums.org"
									/>
									<entry
									key=
									"stavrogin"
									value=
									"stavrogin@gov.org"
									/>
									<entry
									key=
									"porfiry"
									value=
									"porfiry@gov.org"
									/>
									</util:map>

You can also explicitly control the exact type of Mapthat will be instantiated and populated via the use of the 'map-class'attribute on the <util:map/>element. For example, if we really need a java.util.TreeMapto be instantiated, we could use the following configuration:

									<util:map
									id=
									"emails"
									map-class=
									"java.util.TreeMap"
									>
									<entry
									key=
									"pechorin"
									value=
									"pechorin@hero.org"
									/>
									<entry
									key=
									"raskolnikov"
									value=
									"raskolnikov@slums.org"
									/>
									<entry
									key=
									"stavrogin"
									value=
									"stavrogin@gov.org"
									/>
									<entry
									key=
									"porfiry"
									value=
									"porfiry@gov.org"
									/>
									</util:map>

If no 'map-class'attribute is supplied, a Mapimplementation will be chosen by the container.

<util:set/>

Before…​

									<!-- creates a java.util.Set instance with values loaded from the supplied 'sourceSet' -->
									<bean
									id=
									"emails"
									class=
									"org.springframework.beans.factory.config.SetFactoryBean"
									>
									<property
									name=
									"sourceSet"
									>
									<set>
									<value>pechorin@hero.org
									</value>
									<value>raskolnikov@slums.org
									</value>
									<value>stavrogin@gov.org
									</value>
									<value>porfiry@gov.org
									</value>
									</set>
									</property>
									</bean>

The above configuration uses a Spring FactoryBeanimplementation, the SetFactoryBean, to create a java.util.Setinstance initialized with values taken from the supplied 'sourceSet'.

After…​

									<!-- creates a java.util.Set instance with the supplied values -->
									<util:set
									id=
									"emails"
									>
									<value>pechorin@hero.org
									</value>
									<value>raskolnikov@slums.org
									</value>
									<value>stavrogin@gov.org
									</value>
									<value>porfiry@gov.org
									</value>
									</util:set>

You can also explicitly control the exact type of Setthat will be instantiated and populated via the use of the 'set-class'attribute on the <util:set/>element. For example, if we really need a java.util.TreeSetto be instantiated, we could use the following configuration:

									<util:set
									id=
									"emails"
									set-class=
									"java.util.TreeSet"
									>
									<value>pechorin@hero.org
									</value>
									<value>raskolnikov@slums.org
									</value>
									<value>stavrogin@gov.org
									</value>
									<value>porfiry@gov.org
									</value>
									</util:set>

If no 'set-class'attribute is supplied, a Setimplementation will be chosen by the container.

41.2.3 the jee schema

The jeetags deal with Java EE (Java Enterprise Edition)-related configuration issues, such as looking up a JNDI object and defining EJB references.

To use the tags in the jeeschema, you need to have the following preamble at the top of your Spring XML configuration file; the text in the following snippet references the correct schema so that the tags in the jeenamespace are available to you.

								<?xml version="1.0" encoding="UTF-8"?>
								<beans
								xmlns=
								"http://www.springframework.org/schema/beans"
								xmlns:xsi=
								"http://www.w3.org/2001/XMLSchema-instance"
								
									xmlns:jee="http://www.springframework.org/schema/jee"xsi:schemaLocation=" http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
								
									http://www.springframework.org/schema/jee http://www.springframework.org/schema/jee/spring-jee.xsd">
								<!-- bean definitions here -->
								</beans>

<jee:jndi-lookup/> (simple)

Before…​

									<bean
									id=
									"
									
										dataSource" class="org.springframework.jndi.JndiObjectFactoryBean">
									<property
									name=
									"jndiName"
									value=
									"jdbc/MyDataSource"
									/>
									</bean>
									<bean
									id=
									"userDao"
									class=
									"com.foo.JdbcUserDao"
									>
									<!-- Spring will do the cast automatically (as usual) -->
									<property
									name=
									"dataSource"
									ref=
									"
									
										dataSource"/>
									</bean>

After…​

									<jee:jndi-lookup
									id=
									"
									
										dataSource" jndi-name="jdbc/MyDataSource"/>
									<bean
									id=
									"userDao"
									class=
									"com.foo.JdbcUserDao"
									>
									<!-- Spring will do the cast automatically (as usual) -->
									<property
									name=
									"dataSource"
									ref=
									"
									
										dataSource"/>
									</bean>

<jee:jndi-lookup/> (with single JNDI environment setting)

Before…​

									<bean
									id=
									"simple"
									class=
									"org.springframework.jndi.JndiObjectFactoryBean"
									>
									<property
									name=
									"jndiName"
									value=
									"jdbc/MyDataSource"
									/>
									<property
									name=
									"jndiEnvironment"
									>
									<props>
									<prop
									key=
									"foo"
									>bar
									</prop>
									</props>
									</property>
									</bean>

After…​

									<jee:jndi-lookup
									id=
									"simple"
									jndi-name=
									"jdbc/MyDataSource"
									>
									<jee:environment>foo=bar
									</jee:environment>
									</jee:jndi-lookup>

<jee:jndi-lookup/> (with multiple JNDI environment settings)

Before…​

									<bean
									id=
									"simple"
									class=
									"org.springframework.jndi.JndiObjectFactoryBean"
									>
									<property
									name=
									"jndiName"
									value=
									"jdbc/MyDataSource"
									/>
									<property
									name=
									"jndiEnvironment"
									>
									<props>
									<prop
									key=
									"foo"
									>bar
									</prop>
									<prop
									key=
									"ping"
									>pong
									</prop>
									</props>
									</property>
									</bean>

After…​

									<jee:jndi-lookup
									id=
									"simple"
									jndi-name=
									"jdbc/MyDataSource"
									>
									<!-- newline-separated, key-value pairs for the environment (standard Properties format) -->
									<jee:environment>foo=bar ping=pong
									</jee:environment>
									</jee:jndi-lookup>

<jee:jndi-lookup/> (complex)

Before…​

									<bean
									id=
									"simple"
									class=
									"org.springframework.jndi.JndiObjectFactoryBean"
									>
									<property
									name=
									"jndiName"
									value=
									"jdbc/MyDataSource"
									/>
									<property
									name=
									"cache"
									value=
									"true"
									/>
									<property
									name=
									"resourceRef"
									value=
									"true"
									/>
									<property
									name=
									"lookupOnStartup"
									value=
									"false"
									/>
									<property
									name=
									"expectedType"
									value=
									"com.myapp.DefaultFoo"
									/>
									<property
									name=
									"proxyInterface"
									value=
									"com.myapp.Foo"
									/>
									</bean>

After…​

									<jee:jndi-lookup
									id=
									"simple"
									jndi-name=
									"jdbc/MyDataSource"
									cache=
									"true"
									resource-ref=
									"true"
									lookup-on-startup=
									"false"
									expected-type=
									"com.myapp.DefaultFoo"
									proxy-interface=
									"com.myapp.Foo"
									/>

<jee:local-slsb/> (simple)

The <jee:local-slsb/>tag configures a reference to an EJB Stateless SessionBean.

Before…​

									<bean
									id=
									"simple"
									class=
									"org.springframework.ejb.access.LocalStatelessSessionProxyFactoryBean"
									>
									<property
									name=
									"jndiName"
									value=
									"ejb/RentalServiceBean"
									/>
									<property
									name=
									"businessInterface"
									value=
									"com.foo.service.RentalService"
									/>
									</bean>

After…​

									<jee:local-slsb
									id=
									"simpleSlsb"
									jndi-name=
									"ejb/RentalServiceBean"
									business-interface=
									"com.foo.service.RentalService"
									/>

<jee:local-slsb/> (complex)

									<bean
									id=
									"complexLocalEjb"
									class=
									"org.springframework.ejb.access.LocalStatelessSessionProxyFactoryBean"
									>
									<property
									name=
									"jndiName"
									value=
									"ejb/RentalServiceBean"
									/>
									<property
									name=
									"businessInterface"
									value=
									"com.foo.service.RentalService"
									/>
									<property
									name=
									"cacheHome"
									value=
									"true"
									/>
									<property
									name=
									"lookupHomeOnStartup"
									value=
									"true"
									/>
									<property
									name=
									"resourceRef"
									value=
									"true"
									/>
									</bean>

After…​

									<jee:local-slsb
									id=
									"complexLocalEjb"
									jndi-name=
									"ejb/RentalServiceBean"
									business-interface=
									"com.foo.service.RentalService"
									cache-home=
									"true"
									lookup-home-on-startup=
									"true"
									resource-ref=
									"true"
									>

<jee:remote-slsb/>

The <jee:remote-slsb/>tag configures a reference to a remoteEJB Stateless SessionBean.

Before…​

									<bean
									id=
									"complexRemoteEjb"
									class=
									"org.springframework.ejb.access.SimpleRemoteStatelessSessionProxyFactoryBean"
									>
									<property
									name=
									"jndiName"
									value=
									"ejb/MyRemoteBean"
									/>
									<property
									name=
									"businessInterface"
									value=
									"com.foo.service.RentalService"
									/>
									<property
									name=
									"cacheHome"
									value=
									"true"
									/>
									<property
									name=
									"lookupHomeOnStartup"
									value=
									"true"
									/>
									<property
									name=
									"resourceRef"
									value=
									"true"
									/>
									<property
									name=
									"homeInterface"
									value=
									"com.foo.service.RentalService"
									/>
									<property
									name=
									"refreshHomeOnConnectFailure"
									value=
									"true"
									/>
									</bean>

After…​

									<jee:remote-slsb
									id=
									"complexRemoteEjb"
									jndi-name=
									"ejb/MyRemoteBean"
									business-interface=
									"com.foo.service.RentalService"
									cache-home=
									"true"
									lookup-home-on-startup=
									"true"
									resource-ref=
									"true"
									home-interface=
									"com.foo.service.RentalService"
									refresh-home-on-connect-failure=
									"true"
									>

41.2.4 the lang schema

The langtags deal with exposing objects that have been written in a dynamic language such as JRuby or Groovy as beans in the Spring container.

These tags (and the dynamic language support) are comprehensively covered in the chapter entitled Chapter 35, Dynamic language support . Please do consult that chapter for full details on this support and the langtags themselves.

In the interest of completeness, to use the tags in the langschema, you need to have the following preamble at the top of your Spring XML configuration file; the text in the following snippet references the correct schema so that the tags in the langnamespace are available to you.

								<?xml version="1.0" encoding="UTF-8"?>
								<beans
								xmlns=
								"http://www.springframework.org/schema/beans"
								xmlns:xsi=
								"http://www.w3.org/2001/XMLSchema-instance"
								
									xmlns:lang="http://www.springframework.org/schema/lang"xsi:schemaLocation=" http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
								
									http://www.springframework.org/schema/lang http://www.springframework.org/schema/lang/spring-lang.xsd">
								<!-- bean definitions here -->
								</beans>

41.2.5 the jms schema

The jmstags deal with configuring JMS-related beans such as Spring’s MessageListenerContainers. These tags are detailed in the section of the JMS chapterentitled Section 30.7, “JMS namespace support”. Please do consult that chapter for full details on this support and the jmstags themselves.

In the interest of completeness, to use the tags in the jmsschema, you need to have the following preamble at the top of your Spring XML configuration file; the text in the following snippet references the correct schema so that the tags in the jmsnamespace are available to you.

								<?xml version="1.0" encoding="UTF-8"?>
								<beans
								xmlns=
								"http://www.springframework.org/schema/beans"
								xmlns:xsi=
								"http://www.w3.org/2001/XMLSchema-instance"
								
									xmlns:jms="http://www.springframework.org/schema/jms"xsi:schemaLocation=" http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
								
									http://www.springframework.org/schema/jms http://www.springframework.org/schema/jms/spring-jms.xsd">
								<!-- bean definitions here -->
								</beans>

41.2.6 the tx (transaction) schema

The txtags deal with configuring all of those beans in Spring’s comprehensive support for transactions. These tags are covered in the chapter entitled Chapter 17, Transaction Management .

[Tip] Tip

You are strongly encouraged to look at the 'spring-tx.xsd'file that ships with the Spring distribution. This file is (of course), the XML Schema for Spring’s transaction configuration, and covers all of the various tags in the txnamespace, including attribute defaults and suchlike. This file is documented inline, and thus the information is not repeated here in the interests of adhering to the DRY (Don’t Repeat Yourself) principle.

In the interest of completeness, to use the tags in the txschema, you need to have the following preamble at the top of your Spring XML configuration file; the text in the following snippet references the correct schema so that the tags in the txnamespace are available to you.

								<?xml version="1.0" encoding="UTF-8"?>
								<beans
								xmlns=
								"http://www.springframework.org/schema/beans"
								xmlns:xsi=
								"http://www.w3.org/2001/XMLSchema-instance"
								xmlns:aop=
								"http://www.springframework.org/schema/aop"
								
									xmlns:tx="http://www.springframework.org/schema/tx"xsi:schemaLocation=" http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
								
									http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsdhttp://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">
								<!-- bean definitions here -->
								</beans>
[Note] Note

Often when using the tags in the txnamespace you will also be using the tags from the aopnamespace (since the declarative transaction support in Spring is implemented using AOP). The above XML snippet contains the relevant lines needed to reference the aopschema so that the tags in the aopnamespace are available to you.

41.2.7 the aop schema

The aoptags deal with configuring all things AOP in Spring: this includes Spring’s own proxy-based AOP framework and Spring’s integration with the AspectJ AOP framework. These tags are comprehensively covered in the chapter entitled Chapter 11, Aspect Oriented Programming with Spring .

In the interest of completeness, to use the tags in the aopschema, you need to have the following preamble at the top of your Spring XML configuration file; the text in the following snippet references the correct schema so that the tags in the aopnamespace are available to you.

								<?xml version="1.0" encoding="UTF-8"?>
								<beans
								xmlns=
								"http://www.springframework.org/schema/beans"
								xmlns:xsi=
								"http://www.w3.org/2001/XMLSchema-instance"
								
									xmlns:aop="http://www.springframework.org/schema/aop"xsi:schemaLocation=" http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
								
									http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">
								<!-- bean definitions here -->
								</beans>

41.2.8 the context schema

The contexttags deal with ApplicationContextconfiguration that relates to plumbing - that is, not usually beans that are important to an end-user but rather beans that do a lot of grunt work in Spring, such as BeanfactoryPostProcessors. The following snippet references the correct schema so that the tags in the contextnamespace are available to you.

								<?xml version="1.0" encoding="UTF-8"?>
								<beans
								xmlns=
								"http://www.springframework.org/schema/beans"
								xmlns:xsi=
								"http://www.w3.org/2001/XMLSchema-instance"
								
									xmlns:context="http://www.springframework.org/schema/context"xsi:schemaLocation=" http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
								
									http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">
								<!-- bean definitions here -->
								</beans>
[Note] Note

The contextschema was only introduced in Spring 2.5.

<property-placeholder/>

This element activates the replacement of ${…​}placeholders, resolved against the specified properties file (as a Spring resource location). This element is a convenience mechanism that sets up a PropertyPlaceholderConfigurerfor you; if you need more control over the PropertyPlaceholderConfigurer, just define one yourself explicitly.

<annotation-config/>

Activates the Spring infrastructure for various annotations to be detected in bean classes: Spring’s @Requiredand @Autowired, as well as JSR 250’s @PostConstruct, @PreDestroyand @Resource(if available), and JPA’s @PersistenceContextand @PersistenceUnit(if available). Alternatively, you can choose to activate the individual BeanPostProcessorsfor those annotations explicitly.

[Note] Note

This element does notactivate processing of Spring’s @Transactionalannotation. Use the <tx:annotation-driven/>element for that purpose.

<component-scan/>

This element is detailed in Section 7.9, “Annotation-based container configuration”.

<load-time-weaver/>

This element is detailed in Section 11.8.4, “Load-time weaving with AspectJ in the Spring Framework”.

<spring-configured/>

This element is detailed in Section 11.8.1, “Using AspectJ to dependency inject domain objects with Spring”.

<mbean-export/>

This element is detailed in Section 31.4.3, “Configuring annotation based MBean export”.

41.2.9 the tool schema

The tooltags are for use when you want to add tooling-specific metadata to your custom configuration elements. This metadata can then be consumed by tools that are aware of this metadata, and the tools can then do pretty much whatever they want with it (validation, etc.).

The tooltags are not documented in this release of Spring as they are currently undergoing review. If you are a third party tool vendor and you would like to contribute to this review process, then do mail the Spring mailing list. The currently supported tooltags can be found in the file 'spring-tool.xsd'in the 'src/org/springframework/beans/factory/xml'directory of the Spring source distribution.

41.2.10 the jdbc schema

The jdbctags allow you to quickly configure an embedded database or initialize an existing data source. These tags are documented in Section 19.8, “Embedded database support”and Section 19.9, “Initializing a DataSource”respectively.

To use the tags in the jdbcschema, you need to have the following preamble at the top of your Spring XML configuration file; the text in the following snippet references the correct schema so that the tags in the jdbcnamespace are available to you.

								<?xml version="1.0" encoding="UTF-8"?>
								<beans
								xmlns=
								"http://www.springframework.org/schema/beans"
								xmlns:xsi=
								"http://www.w3.org/2001/XMLSchema-instance"
								
									xmlns:jdbc="http://www.springframework.org/schema/jdbc"xsi:schemaLocation=" http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
								
									http://www.springframework.org/schema/jdbc http://www.springframework.org/schema/jdbc/spring-jdbc.xsd">
								<!-- bean definitions here -->
								</beans>

41.2.11 the cache schema

The cachetags can be used to enable support for Spring’s @CacheEvict, @CachePutand @Cachingannotations. It it also supports declarative XML-based caching. See Section 36.3.6, “Enable caching annotations”and Section 36.5, “Declarative XML-based caching”for details.

To use the tags in the cacheschema, you need to have the following preamble at the top of your Spring XML configuration file; the text in the following snippet references the correct schema so that the tags in the cachenamespace are available to you.

								<?xml version="1.0" encoding="UTF-8"?>
								<beans
								xmlns=
								"http://www.springframework.org/schema/beans"
								xmlns:xsi=
								"http://www.w3.org/2001/XMLSchema-instance"
								
									xmlns:cache="http://www.springframework.org/schema/cache"xsi:schemaLocation=" http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
								
									http://www.springframework.org/schema/cache http://www.springframework.org/schema/cache/spring-cache.xsd">
								<!-- bean definitions here -->
								</beans>

41.2.12 the beans schema

Last but not least we have the tags in the beansschema. These are the same tags that have been in Spring since the very dawn of the framework. Examples of the various tags in the beansschema are not shown here because they are quite comprehensively covered in Section 7.4.2, “Dependencies and configuration in detail”(and indeed in that entire chapter).

One thing that is new to the beans tags themselves in Spring 2.0 is the idea of arbitrary bean metadata. In Spring 2.0 it is now possible to add zero or more key / value pairs to <bean/>XML definitions. What, if anything, is done with this extra metadata is totally up to your own custom logic (and so is typically only of use if you are writing your own custom tags as described in the appendix entitled Chapter 42, Extensible XML authoring ).

Find below an example of the <meta/>tag in the context of a surrounding <bean/>(please note that without any logic to interpret it the metadata is effectively useless as-is).

								<?xml version="1.0" encoding="UTF-8"?>
								<beans
								xmlns=
								"http://www.springframework.org/schema/beans"
								xmlns:xsi=
								"http://www.w3.org/2001/XMLSchema-instance"
								xsi:schemaLocation=
								" http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd"
								>
								<bean
								id=
								"foo"
								class=
								"x.y.Foo"
								>
								
									<meta key="cacheName" value="foo"/>
								<property
								name=
								"name"
								value=
								"Rick"
								/>
								</bean>
								</beans>

In the case of the above example, you would assume that there is some logic that will consume the bean definition and set up some caching infrastructure using the supplied metadata.

42. Extensible XML authoring

42.1 Introduction

Since version 2.0, Spring has featured a mechanism for schema-based extensions to the basic Spring XML format for defining and configuring beans. This section is devoted to detailing how you would go about writing your own custom XML bean definition parsers and integrating such parsers into the Spring IoC container.

To facilitate the authoring of configuration files using a schema-aware XML editor, Spring’s extensible XML configuration mechanism is based on XML Schema. If you are not familiar with Spring’s current XML configuration extensions that come with the standard Spring distribution, please first read the appendix entitled ???.

Creating new XML configuration extensions can be done by following these (relatively) simple steps:

  • Authoringan XML schema to describe your custom element(s).
  • Codinga custom NamespaceHandlerimplementation (this is an easy step, don’t worry).
  • Codingone or more BeanDefinitionParserimplementations (this is where the real work is done).
  • Registeringthe above artifacts with Spring (this too is an easy step).

What follows is a description of each of these steps. For the example, we will create an XML extension (a custom XML element) that allows us to configure objects of the type SimpleDateFormat(from the java.textpackage) in an easy manner. When we are done, we will be able to define bean definitions of type SimpleDateFormatlike this:

							<myns:dateformat
							id=
							"dateFormat"
							pattern=
							"yyyy-MM-dd HH:mm"
							lenient=
							"true"
							/>

(Don’t worry about the fact that this example is very simple; much more detailed examples follow afterwards. The intent in this first simple example is to walk you through the basic steps involved.)

42.2 Authoring the schema

Creating an XML configuration extension for use with Spring’s IoC container starts with authoring an XML Schema to describe the extension. What follows is the schema we’ll use to configure SimpleDateFormatobjects.

							<!-- myns.xsd (inside package org/springframework/samples/xml) -->
							<?xml version="1.0" encoding="UTF-8"?>
							<xsd:schema
							xmlns=
							"http://www.mycompany.com/schema/myns"
							xmlns:xsd=
							"http://www.w3.org/2001/XMLSchema"
							xmlns:beans=
							"http://www.springframework.org/schema/beans"
							targetNamespace=
							"http://www.mycompany.com/schema/myns"
							elementFormDefault=
							"qualified"
							attributeFormDefault=
							"unqualified"
							>
							<xsd:import
							namespace=
							"http://www.springframework.org/schema/beans"
							/>
							<xsd:element
							name=
							"dateformat"
							>
							<xsd:complexType>
							<xsd:complexContent>
							<xsd:extension
							base=
							"beans:identifiedType"
							>
							<xsd:attribute
							name=
							"lenient"
							type=
							"xsd:boolean"
							/>
							<xsd:attribute
							name=
							"pattern"
							type=
							"xsd:string"
							use=
							"required"
							/>
							</xsd:extension>
							</xsd:complexContent>
							</xsd:complexType>
							</xsd:element>
							</xsd:schema>

(The emphasized line contains an extension base for all tags that will be identifiable (meaning they have an idattribute that will be used as the bean identifier in the container). We are able to use this attribute because we imported the Spring-provided 'beans'namespace.)

The above schema will be used to configure SimpleDateFormatobjects, directly in an XML application context file using the <myns:dateformat/>element.

							<myns:dateformat
							id=
							"dateFormat"
							pattern=
							"yyyy-MM-dd HH:mm"
							lenient=
							"true"
							/>

Note that after we’ve created the infrastructure classes, the above snippet of XML will essentially be exactly the same as the following XML snippet. In other words, we’re just creating a bean in the container, identified by the name 'dateFormat'of type SimpleDateFormat, with a couple of properties set.

							<bean
							id=
							"dateFormat"
							class=
							"java.text.SimpleDateFormat"
							>
							<constructor-arg
							value=
							"yyyy-HH-dd HH:mm"
							/>
							<property
							name=
							"lenient"
							value=
							"true"
							/>
							</bean>
[Note] Note

The schema-based approach to creating configuration format allows for tight integration with an IDE that has a schema-aware XML editor. Using a properly authored schema, you can use autocompletion to have a user choose between several configuration options defined in the enumeration.

42.3 Coding a NamespaceHandler

In addition to the schema, we need a NamespaceHandlerthat will parse all elements of this specific namespace Spring encounters while parsing configuration files. The NamespaceHandlershould in our case take care of the parsing of the myns:dateformatelement.

The NamespaceHandlerinterface is pretty simple in that it features just three methods:

  • init()- allows for initialization of the NamespaceHandlerand will be called by Spring before the handler is used
  • BeanDefinition parse(Element, ParserContext)- called when Spring encounters a top-level element (not nested inside a bean definition or a different namespace). This method can register bean definitions itself and/or return a bean definition.
  • BeanDefinitionHolder decorate(Node, BeanDefinitionHolder, ParserContext)- called when Spring encounters an attribute or nested element of a different namespace. The decoration of one or more bean definitions is used for example with the out-of-the-box scopes Spring 2.0 supports. We’ll start by highlighting a simple example, without using decoration, after which we will show decoration in a somewhat more advanced example.

Although it is perfectly possible to code your own NamespaceHandlerfor the entire namespace (and hence provide code that parses each and every element in the namespace), it is often the case that each top-level XML element in a Spring XML configuration file results in a single bean definition (as in our case, where a single <myns:dateformat/>element results in a single SimpleDateFormatbean definition). Spring features a number of convenience classes that support this scenario. In this example, we’ll make use the NamespaceHandlerSupportclass:

							packageorg.springframework.samples.xml;
							importorg.springframework.beans.factory.xml.NamespaceHandlerSupport;
							public
							classMyNamespaceHandler
							extendsNamespaceHandlerSupport {
							public
							voidinit() {
							
								registerBeanDefinitionParser("dateformat", new SimpleDateFormatBeanDefinitionParser());} }

The observant reader will notice that there isn’t actually a whole lot of parsing logic in this class. Indeed…​ the NamespaceHandlerSupportclass has a built in notion of delegation. It supports the registration of any number of BeanDefinitionParserinstances, to which it will delegate to when it needs to parse an element in its namespace. This clean separation of concerns allows a NamespaceHandlerto handle the orchestration of the parsing of allof the custom elements in its namespace, while delegating to BeanDefinitionParsersto do the grunt work of the XML parsing; this means that each BeanDefinitionParserwill contain just the logic for parsing a single custom element, as we can see in the next step

42.4 BeanDefinitionParser

A BeanDefinitionParserwill be used if the NamespaceHandlerencounters an XML element of the type that has been mapped to the specific bean definition parser (which is 'dateformat'in this case). In other words, the BeanDefinitionParseris responsible for parsing onedistinct top-level XML element defined in the schema. In the parser, we’ll have access to the XML element (and thus its subelements too) so that we can parse our custom XML content, as can be seen in the following example:

							packageorg.springframework.samples.xml;
							importorg.springframework.beans.factory.support.BeanDefinitionBuilder;
							importorg.springframework.beans.factory.xml.AbstractSingleBeanDefinitionParser;
							importorg.springframework.util.StringUtils;
							importorg.w3c.dom.Element;
							importjava.text.SimpleDateFormat;
							public
							classSimpleDateFormatBeanDefinitionParser
							extendsAbstractSingleBeanDefinitionParser {
							
							
								1
							protectedClass getBeanClass(Element element) {
							returnSimpleDateFormat.
							class;
							
							
								2}
							protected
							voiddoParse(Element element, BeanDefinitionBuilder bean) {
							// this will never be null since the schema explicitly requires that a value be suppliedString pattern = element.getAttribute(
							"pattern"); bean.addConstructorArg(pattern);
							// this however is an optional propertyString lenient = element.getAttribute(
							"lenient");
							if(StringUtils.hasText(lenient)) { bean.addPropertyValue(
							"lenient", Boolean.valueOf(lenient)); } } }

1

We use the Spring-provided AbstractSingleBeanDefinitionParserto handle a lot of the basic grunt work of creating a single BeanDefinition.

2

We supply the AbstractSingleBeanDefinitionParsersuperclass with the type that our single BeanDefinitionwill represent.

In this simple case, this is all that we need to do. The creation of our single BeanDefinitionis handled by the AbstractSingleBeanDefinitionParsersuperclass, as is the extraction and setting of the bean definition’s unique identifier.

42.5 Registering the handler and the schema

The coding is finished! All that remains to be done is to somehow make the Spring XML parsing infrastructure aware of our custom element; we do this by registering our custom namespaceHandlerand custom XSD file in two special purpose properties files. These properties files are both placed in a 'META-INF'directory in your application, and can, for example, be distributed alongside your binary classes in a JAR file. The Spring XML parsing infrastructure will automatically pick up your new extension by consuming these special properties files, the formats of which are detailed below.

42.5.1 'META-INF/spring.handlers'

The properties file called 'spring.handlers'contains a mapping of XML Schema URIs to namespace handler classes. So for our example, we need to write the following:

http\://www.mycompany.com/schema/myns=org.springframework.samples.xml.MyNamespaceHandler

(The ':'character is a valid delimiter in the Java properties format, and so the ':'character in the URI needs to be escaped with a backslash.)

The first part (the key) of the key-value pair is the URI associated with your custom namespace extension, and needs to match exactlythe value of the 'targetNamespace'attribute as specified in your custom XSD schema.

42.5.2 'META-INF/spring.schemas'

The properties file called 'spring.schemas'contains a mapping of XML Schema locations (referred to along with the schema declaration in XML files that use the schema as part of the 'xsi:schemaLocation'attribute) to classpathresources. This file is needed to prevent Spring from absolutely having to use a default EntityResolverthat requires Internet access to retrieve the schema file. If you specify the mapping in this properties file, Spring will search for the schema on the classpath (in this case 'myns.xsd'in the 'org.springframework.samples.xml'package):

http\://www.mycompany.com/schema/myns/myns.xsd=org/springframework/samples/xml/myns.xsd

The upshot of this is that you are encouraged to deploy your XSD file(s) right alongside the NamespaceHandlerand BeanDefinitionParserclasses on the classpath.

42.6 Using a custom extension in your Spring XML configuration

Using a custom extension that you yourself have implemented is no different from using one of the 'custom' extensions that Spring provides straight out of the box. Find below an example of using the custom <dateformat/>element developed in the previous steps in a Spring XML configuration file.

							<?xml version="1.0" encoding="UTF-8"?>
							<beans
							xmlns=
							"http://www.springframework.org/schema/beans"
							xmlns:xsi=
							"http://www.w3.org/2001/XMLSchema-instance"
							xmlns:myns=
							"http://www.mycompany.com/schema/myns"
							xsi:schemaLocation=
							" http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.mycompany.com/schema/myns http://www.mycompany.com/schema/myns/myns.xsd"
							>
							<!-- as a top-level bean -->
							<myns:dateformat
							id=
							"defaultDateFormat"
							pattern=
							"yyyy-MM-dd HH:mm"
							lenient=
							"true"
							/>
							<bean
							id=
							"jobDetailTemplate"
							abstract=
							"true"
							>
							<property
							name=
							"dateFormat"
							>
							<!-- as an inner bean -->
							<myns:dateformat
							pattern=
							"HH:mm MM-dd-yyyy"
							/>
							</property>
							</bean>
							</beans>

42.7 Meatier examples

Find below some much meatier examples of custom XML extensions.

42.7.1 Nesting custom tags within custom tags

This example illustrates how you might go about writing the various artifacts required to satisfy a target of the following configuration:

								<?xml version="1.0" encoding="UTF-8"?>
								<beans
								xmlns=
								"http://www.springframework.org/schema/beans"
								xmlns:xsi=
								"http://www.w3.org/2001/XMLSchema-instance"
								xmlns:foo=
								"http://www.foo.com/schema/component"
								xsi:schemaLocation=
								" http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.foo.com/schema/component http://www.foo.com/schema/component/component.xsd"
								>
								<foo:component
								id=
								"bionic-family"
								name=
								"Bionic-1"
								>
								<foo:component
								name=
								"Mother-1"
								>
								<foo:component
								name=
								"Karate-1"
								/>
								<foo:component
								name=
								"Sport-1"
								/>
								</foo:component>
								<foo:component
								name=
								"Rock-1"
								/>
								</foo:component>
								</beans>

The above configuration actually nests custom extensions within each other. The class that is actually configured by the above <foo:component/>element is the Componentclass (shown directly below). Notice how the Componentclass does notexpose a setter method for the 'components'property; this makes it hard (or rather impossible) to configure a bean definition for the Componentclass using setter injection.

								packagecom.foo;
								importjava.util.ArrayList;
								importjava.util.List;
								public
								classComponent {
								privateString name;
								privateList<Component> components =
								newArrayList<Component> ();
								// mmm, there is no setter method for the 'components'
								public
								voidaddComponent(Component component) {
								this.components.add(component); }
								publicList<Component> getComponents() {
								returncomponents; }
								publicString getName() {
								returnname; }
								public
								voidsetName(String name) {
								this.name = name; } }

The typical solution to this issue is to create a custom FactoryBeanthat exposes a setter property for the 'components'property.

								packagecom.foo;
								importorg.springframework.beans.factory.FactoryBean;
								importjava.util.List;
								public
								classComponentFactoryBean
								implementsFactoryBean<Component> {
								privateComponent parent;
								privateList<Component> children;
								public
								voidsetParent(Component parent) {
								this.parent = parent; }
								public
								voidsetChildren(List<Component> children) {
								this.children = children; }
								publicComponent getObject()
								throwsException {
								if(
								this.children != null &&
								this.children.size() >
								0) {
								for(Component child : children) {
								this.parent.addComponent(child); } }
								return
								this.parent; }
								publicClass<Component> getObjectType() {
								returnComponent.
								class; }
								public
								booleanisSingleton() {
								returntrue; } }

This is all very well, and does work nicely, but exposes a lot of Spring plumbing to the end user. What we are going to do is write a custom extension that hides away all of this Spring plumbing. If we stick to the steps described previously, we’ll start off by creating the XSD schema to define the structure of our custom tag.

								<?xml version="1.0" encoding="UTF-8" standalone="no"?>
								<xsd:schema
								xmlns=
								"http://www.foo.com/schema/component"
								xmlns:xsd=
								"http://www.w3.org/2001/XMLSchema"
								targetNamespace=
								"http://www.foo.com/schema/component"
								elementFormDefault=
								"qualified"
								attributeFormDefault=
								"unqualified"
								>
								<xsd:element
								name=
								"component"
								>
								<xsd:complexType>
								<xsd:choice
								minOccurs=
								"0"
								maxOccurs=
								"unbounded"
								>
								<xsd:element
								ref=
								"component"
								/>
								</xsd:choice>
								<xsd:attribute
								name=
								"id"
								type=
								"xsd:ID"
								/>
								<xsd:attribute
								name=
								"name"
								use=
								"required"
								type=
								"xsd:string"
								/>
								</xsd:complexType>
								</xsd:element>
								</xsd:schema>

We’ll then create a custom NamespaceHandler.

								packagecom.foo;
								importorg.springframework.beans.factory.xml.NamespaceHandlerSupport;
								public
								classComponentNamespaceHandler
								extendsNamespaceHandlerSupport {
								public
								voidinit() { registerBeanDefinitionParser(
								"component",
								newComponentBeanDefinitionParser()); } }

Next up is the custom BeanDefinitionParser. Remember that what we are creating is a BeanDefinitiondescribing a ComponentFactoryBean.

								packagecom.foo;
								importorg.springframework.beans.factory.config.BeanDefinition;
								importorg.springframework.beans.factory.support.AbstractBeanDefinition;
								importorg.springframework.beans.factory.support.BeanDefinitionBuilder;
								importorg.springframework.beans.factory.support.ManagedList;
								importorg.springframework.beans.factory.xml.AbstractBeanDefinitionParser;
								importorg.springframework.beans.factory.xml.ParserContext;
								importorg.springframework.util.xml.DomUtils;
								importorg.w3c.dom.Element;
								importjava.util.List;
								public
								classComponentBeanDefinitionParser
								extendsAbstractBeanDefinitionParser {
								protectedAbstractBeanDefinition parseInternal(Element element, ParserContext parserContext) {
								returnparseComponentElement(element); }
								private
								staticAbstractBeanDefinition parseComponentElement(Element element) { BeanDefinitionBuilder factory = BeanDefinitionBuilder.rootBeanDefinition(ComponentFactoryBean.
								class); factory.addPropertyValue(
								"parent", parseComponent(element)); List<Element> childElements = DomUtils.getChildElementsByTagName(element,
								"component");
								if(childElements != null && childElements.size() >
								0) { parseChildComponents(childElements, factory); }
								returnfactory.getBeanDefinition(); }
								private
								staticBeanDefinition parseComponent(Element element) { BeanDefinitionBuilder component = BeanDefinitionBuilder.rootBeanDefinition(Component.
								class); component.addPropertyValue(
								"name", element.getAttribute(
								"name"));
								returncomponent.getBeanDefinition(); }
								private
								static
								voidparseChildComponents(List<Element> childElements, BeanDefinitionBuilder factory) { ManagedList<BeanDefinition> children =
								newManagedList<BeanDefinition>(childElements.size());
								for(Element element : childElements) { children.add(parseComponentElement(element)); } factory.addPropertyValue(
								"children", children); } }

Lastly, the various artifacts need to be registered with the Spring XML infrastructure.

# in 'META-INF/spring.handlers' http\://www.foo.com/schema/component=com.foo.ComponentNamespaceHandler
# in 'META-INF/spring.schemas' http\://www.foo.com/schema/component/component.xsd=com/foo/component.xsd

42.7.2 Custom attributes on 'normal' elements

Writing your own custom parser and the associated artifacts isn’t hard, but sometimes it is not the right thing to do. Consider the scenario where you need to add metadata to already existing bean definitions. In this case you certainly don’t want to have to go off and write your own entire custom extension; rather you just want to add an additional attribute to the existing bean definition element.

By way of another example, let’s say that the service class that you are defining a bean definition for a service object that will (unknown to it) be accessing a clustered JCache, and you want to ensure that the named JCache instance is eagerly started within the surrounding cluster:

								<bean
								id=
								"checkingAccountService"
								class=
								"com.foo.DefaultCheckingAccountService"
								jcache:cache-name=
								"checking.account"
								>
								<!-- other dependencies here... -->
								</bean>

What we are going to do here is create another BeanDefinitionwhen the 'jcache:cache-name'attribute is parsed; this BeanDefinitionwill then initialize the named JCache for us. We will also modify the existing BeanDefinitionfor the 'checkingAccountService'so that it will have a dependency on this new JCache-initializing BeanDefinition.

								packagecom.foo;
								public
								classJCacheInitializer {
								privateString name;
								publicJCacheInitializer(String name) {
								this.name = name; }
								public
								voidinitialize() {
								// lots of JCache API calls to initialize the named cache...} }

Now onto the custom extension. Firstly, the authoring of the XSD schema describing the custom attribute (quite easy in this case).

								<?xml version="1.0" encoding="UTF-8" standalone="no"?>
								<xsd:schema
								xmlns=
								"http://www.foo.com/schema/jcache"
								xmlns:xsd=
								"http://www.w3.org/2001/XMLSchema"
								targetNamespace=
								"http://www.foo.com/schema/jcache"
								elementFormDefault=
								"qualified"
								>
								<xsd:attribute
								name=
								"cache-name"
								type=
								"xsd:string"
								/>
								</xsd:schema>

Next, the associated NamespaceHandler.

								packagecom.foo;
								importorg.springframework.beans.factory.xml.NamespaceHandlerSupport;
								public
								classJCacheNamespaceHandler
								extendsNamespaceHandlerSupport {
								public
								voidinit() {
								super.registerBeanDefinitionDecoratorForAttribute(
								"cache-name",
								newJCacheInitializingBeanDefinitionDecorator()); } }

Next, the parser. Note that in this case, because we are going to be parsing an XML attribute, we write a BeanDefinitionDecoratorrather than a BeanDefinitionParser.

								packagecom.foo;
								importorg.springframework.beans.factory.config.BeanDefinitionHolder;
								importorg.springframework.beans.factory.support.AbstractBeanDefinition;
								importorg.springframework.beans.factory.support.BeanDefinitionBuilder;
								importorg.springframework.beans.factory.xml.BeanDefinitionDecorator;
								importorg.springframework.beans.factory.xml.ParserContext;
								importorg.w3c.dom.Attr;
								importorg.w3c.dom.Node;
								importjava.util.ArrayList;
								importjava.util.Arrays;
								importjava.util.List;
								public
								classJCacheInitializingBeanDefinitionDecorator
								implementsBeanDefinitionDecorator {
								private
								static
								finalString[] EMPTY_STRING_ARRAY =
								newString[
								0];
								publicBeanDefinitionHolder decorate(Node source, BeanDefinitionHolder holder, ParserContext ctx) { String initializerBeanName = registerJCacheInitializer(source, ctx); createDependencyOnJCacheInitializer(holder, initializerBeanName);
								returnholder; }
								private
								voidcreateDependencyOnJCacheInitializer(BeanDefinitionHolder holder, String initializerBeanName) { AbstractBeanDefinition definition = ((AbstractBeanDefinition) holder.getBeanDefinition()); String[] dependsOn = definition.getDependsOn();
								if(dependsOn == null) { dependsOn =
								newString[]{initializerBeanName}; }
								else{ List dependencies =
								newArrayList(Arrays.asList(dependsOn)); dependencies.add(initializerBeanName); dependsOn = (String[]) dependencies.toArray(EMPTY_STRING_ARRAY); } definition.setDependsOn(dependsOn); }
								privateString registerJCacheInitializer(Node source, ParserContext ctx) { String cacheName = ((Attr) source).getValue(); String beanName = cacheName +
								"-initializer";
								if(!ctx.getRegistry().containsBeanDefinition(beanName)) { BeanDefinitionBuilder initializer = BeanDefinitionBuilder.rootBeanDefinition(JCacheInitializer.
								class); initializer.addConstructorArg(cacheName); ctx.getRegistry().registerBeanDefinition(beanName, initializer.getBeanDefinition()); }
								returnbeanName; } }

Lastly, the various artifacts need to be registered with the Spring XML infrastructure.

# in 'META-INF/spring.handlers' http\://www.foo.com/schema/jcache=com.foo.JCacheNamespaceHandler
# in 'META-INF/spring.schemas' http\://www.foo.com/schema/jcache/jcache.xsd=com/foo/jcache.xsd

42.8 Further Resources

Find below links to further resources concerning XML Schema and the extensible XML support described in this chapter.

43. spring JSP Tag Library

43.1 Introduction

One of the view technologies you can use with the Spring Framework is Java Server Pages (JSPs). To help you implement views using Java Server Pages the Spring Framework provides you with some tags for evaluating errors, setting themes and outputting internationalized messages.

Please note that the various tags generated by this form tag library are compliant with the XHTML-1.0-Strict specificationand attendant DTD.

This appendix describes the spring.tldtag library.

43.2 The argument tag

Argument tag based on the JSTL fmt:param tag. The purpose is to support arguments inside the message and theme tags.

Table 43.1. Attributes

Attribute Required? Runtime Expression? Description

value

false

true

The value of the argument.

43.3 The bind tag

Provides BindStatus object for the given bind path. The HTML escaping flag participates in a page-wide or application-wide setting (i.e. by HtmlEscapeTag or a "defaultHtmlEscape" context-param in web.xml).

Table 43.2. Attributes

Attribute Required? Runtime Expression? Description

htmlEscape

false

true

Set HTML escaping for this tag, as boolean value. Overrides the default HTML escaping setting for the current page.

ignoreNestedPath

false

true

Set whether to ignore a nested path, if any. Default is to not ignore.

path

true

true

The path to the bean or bean property to bind status information for. For instance account.name, company.address.zipCode or just employee. The status object will exported to the page scope, specifically for this bean or bean property

43.4 The escapeBody tag

Escapes its enclosed body content, applying HTML escaping and/or JavaScript escaping. The HTML escaping flag participates in a page-wide or application-wide setting (i.e. by HtmlEscapeTag or a "defaultHtmlEscape" context-param in web.xml).

Table 43.3. Attributes

Attribute Required? Runtime Expression? Description

htmlEscape

false

true

Set HTML escaping for this tag, as boolean value. Overrides the default HTML escaping setting for the current page.

javaScriptEscape

false

true

Set JavaScript escaping for this tag, as boolean value. Default is false.

43.5 The eval tag

Evaluates a Spring expression (SpEL) and either prints the result or assigns it to a variable.

Table 43.4. Attributes

Attribute Required? Runtime Expression? Description

expression

true

true

The expression to evaluate.

htmlEscape

false

true

Set HTML escaping for this tag, as a boolean value. Overrides the default HTML escaping setting for the current page.

javaScriptEscape

false

true

Set JavaScript escaping for this tag, as a boolean value. Default is false.

scope

false

true

The scope for the var. 'application', 'session', 'request' and 'page' scopes are supported. Defaults to page scope. This attribute has no effect unless the var attribute is also defined.

var

false

true

The name of the variable to export the evaluation result to. If not specified the evaluation result is converted to a String and written as output.

43.6 The hasBindErrors tag

Provides Errors instance in case of bind errors. The HTML escaping flag participates in a page-wide or application-wide setting (i.e. by HtmlEscapeTag or a "defaultHtmlEscape" context-param in web.xml).

Table 43.5. Attributes

Attribute Required? Runtime Expression? Description

htmlEscape

false

true

Set HTML escaping for this tag, as boolean value. Overrides the default HTML escaping setting for the current page.

name

true

true

The name of the bean in the request, that needs to be inspected for errors. If errors are available for this bean, they will be bound under the 'errors' key.

43.7 The htmlEscape tag

Sets default HTML escape value for the current page. Overrides a "defaultHtmlEscape" context-param in web.xml, if any.

Table 43.6. Attributes

Attribute Required? Runtime Expression? Description

defaultHtmlEscape

true

true

Set the default value for HTML escaping, to be put into the current PageContext.

43.8 The message tag

Retrieves the message with the given code, or text if code isn’t resolvable. The HTML escaping flag participates in a page-wide or application-wide setting (i.e. by HtmlEscapeTag or a "defaultHtmlEscape" context-param in web.xml).

Table 43.7. Attributes

Attribute Required? Runtime Expression? Description

arguments

false

true

Set optional message arguments for this tag, as a (comma-)delimited String (each String argument can contain JSP EL), an Object array (used as argument array), or a single Object (used as single argument).

argumentSeparator

false

true

The separator character to be used for splitting the arguments string value; defaults to a 'comma' (',').

code

false

true

The code (key) to use when looking up the message. If code is not provided, the text attribute will be used.

htmlEscape

false

true

Set HTML escaping for this tag, as boolean value. Overrides the default HTML escaping setting for the current page.

javaScriptEscape

false

true

Set JavaScript escaping for this tag, as boolean value. Default is false.

message

false

true

A MessageSourceResolvable argument (direct or through JSP EL). Fits nicely when used in conjunction with Spring’s own validation error classes which all implement the MessageSourceResolvable interface. For example, this allows you to iterate over all of the errors in a form, passing each error (using a runtime expression) as the value of this 'message' attribute, thus effecting the easy display of such error messages.

scope

false

true

The scope to use when exporting the result to a variable. This attribute is only used when var is also set. Possible values are page, request, session and application.

text

false

true

Default text to output when a message for the given code could not be found. If both text and code are not set, the tag will output null.

var

false

true

The string to use when binding the result to the page, request, session or application scope. If not specified, the result gets outputted to the writer (i.e. typically directly to the JSP).

43.9 The nestedPath tag

Sets a nested path to be used by the bind tag’s path.

Table 43.8. Attributes

Attribute Required? Runtime Expression? Description

path

true

true

Set the path that this tag should apply. E.g. 'customer' to allow bind paths like 'address.street' rather than 'customer.address.street'.

43.10 The param tag

Parameter tag based on the JSTL c:param tag. The sole purpose is to support params inside the url tag.

Table 43.9. Attributes

Attribute Required? Runtime Expression? Description

name

true

true

The name of the parameter.

value

false

true

The value of the parameter.

43.11 The theme tag

Retrieves the theme message with the given code, or text if code isn’t resolvable. The HTML escaping flag participates in a page-wide or application-wide setting (i.e. by HtmlEscapeTag or a "defaultHtmlEscape" context-param in web.xml).

Table 43.10. Attributes

Attribute Required? Runtime Expression? Description

arguments

false

true

Set optional message arguments for this tag, as a (comma-)delimited String (each String argument can contain JSP EL), an Object array (used as argument array), or a single Object (used as single argument).

argumentSeparator

false

true

The separator character to be used for splitting the arguments string value; defaults to a 'comma' (',').

code

false

true

The code (key) to use when looking up the message. If code is not provided, the text attribute will be used.

htmlEscape

false

true

Set HTML escaping for this tag, as boolean value. Overrides the default HTML escaping setting for the current page.

javaScriptEscape

false

true

Set JavaScript escaping for this tag, as boolean value. Default is false.

message

false

true

A MessageSourceResolvable argument (direct or through JSP EL).

scope

false

true

The scope to use when exporting the result to a variable. This attribute is only used when var is also set. Possible values are page, request, session and application.

text

false

true

Default text to output when a message for the given code could not be found. If both text and code are not set, the tag will output null.

var

false

true

The string to use when binding the result to the page, request, session or application scope. If not specified, the result gets outputted to the writer (i.e. typically directly to the JSP).

43.12 The transform tag

Provides transformation of variables to Strings, using an appropriate custom PropertyEditor from BindTag (can only be used inside BindTag). The HTML escaping flag participates in a page-wide or application-wide setting (i.e. by HtmlEscapeTag or a 'defaultHtmlEscape' context-param in web.xml).

Table 43.11. Attributes

Attribute Required? Runtime Expression? Description

htmlEscape

false

true

Set HTML escaping for this tag, as boolean value. Overrides the default HTML escaping setting for the current page.

scope

false

true

The scope to use when exported the result to a variable. This attribute is only used when var is also set. Possible values are page, request, session and application.

value

true

true

The value to transform. This is the actual object you want to have transformed (for instance a Date). Using the PropertyEditor that is currently in use by the 'spring:bind' tag.

var

false

true

The string to use when binding the result to the page, request, session or application scope. If not specified, the result gets outputted to the writer (i.e. typically directly to the JSP).

43.13 The url tag

Creates URLs with support for URI template variables, HTML/XML escaping, and Javascript escaping. Modeled after the JSTL c:url tag with backwards compatibility in mind.

Table 43.12. Attributes

Attribute Required? Runtime Expression? Description

value

true

true

The URL to build. This value can include template {placeholders} that are replaced with the URL encoded value of the named parameter. Parameters must be defined using the param tag inside the body of this tag.

context

false

true

Specifies a remote application context path. The default is the current application context path.

var

false

true

The name of the variable to export the URL value to. If not specified the URL is written as output.

scope

false

true

The scope for the var. 'application', 'session', 'request' and 'page' scopes are supported. Defaults to page scope. This attribute has no effect unless the var attribute is also defined.

htmlEscape

false

true

Set HTML escaping for this tag, as a boolean value. Overrides the default HTML escaping setting for the current page.

javaScriptEscape

false

true

Set JavaScript escaping for this tag, as a boolean value. Default is false.

44. spring-form JSP Tag Library

44.1 Introduction

One of the view technologies you can use with the Spring Framework is Java Server Pages (JSPs). To help you implement views using Java Server Pages the Spring Framework provides you with some tags for evaluating errors, setting themes and outputting internationalized messages.

Please note that the various tags generated by this form tag library are compliant with the XHTML-1.0-Strict specificationand attendant DTD.

This appendix describes the spring-form.tldtag library.

44.2 The button tag

Renders a form field label in an HTML 'button' tag.

Table 44.1. Attributes

Attribute Required? Runtime Expression? Description

disabled

false

true

HTML Optional Attribute. Setting the value of this attribute to 'true' will disable the HTML element.

id

false

true

HTML Standard Attribute

name

false

true

The name attribute for the HTML button tag

value

false

true

The name attribute for the HTML button tag

44.3 The checkbox tag

Renders an HTML 'input' tag with type 'checkbox'.

Table 44.2. Attributes

Attribute Required? Runtime Expression? Description

accesskey

false

true

HTML Standard Attribute

cssClass

false

true

Equivalent to "class" - HTML Optional Attribute

cssErrorClass

false

true

Equivalent to "class" - HTML Optional Attribute. Used when the bound field has errors.

cssStyle

false

true

Equivalent to "style" - HTML Optional Attribute

dir

false

true

HTML Standard Attribute

disabled

false

true

HTML Optional Attribute. Setting the value of this attribute to 'true' will disable the HTML element.

htmlEscape

false

true

Enable/disable HTML escaping of rendered values.

id

false

true

HTML Standard Attribute

label

false

true

Value to be displayed as part of the tag

lang

false

true

HTML Standard Attribute

onblur

false

true

HTML Event Attribute

onchange

false

true

HTML Event Attribute

onclick

false

true

HTML Event Attribute

ondblclick

false

true

HTML Event Attribute

onfocus

false

true

HTML Event Attribute

onkeydown

false

true

HTML Event Attribute

onkeypress

false

true

HTML Event Attribute

onkeyup

false

true

HTML Event Attribute

onmousedown

false

true

HTML Event Attribute

onmousemove

false

true

HTML Event Attribute

onmouseout

false

true

HTML Event Attribute

onmouseover

false

true

HTML Event Attribute

onmouseup

false

true

HTML Event Attribute

path

true

true

Path to property for data binding

tabindex

false

true

HTML Standard Attribute

title

false

true

HTML Standard Attribute

value

false

true

HTML Optional Attribute

44.4 The checkboxes tag

Renders multiple HTML 'input' tags with type 'checkbox'.

Table 44.3. Attributes

Attribute Required? Runtime Expression? Description

accesskey

false

true

HTML Standard Attribute

cssClass

false

true

Equivalent to "class" - HTML Optional Attribute

cssErrorClass

false

true

Equivalent to "class" - HTML Optional Attribute. Used when the bound field has errors.

cssStyle

false

true

Equivalent to "style" - HTML Optional Attribute

delimiter

false

true

Delimiter to use between each 'input' tag with type 'checkbox'. There is no delimiter by default.

dir

false

true

HTML Standard Attribute

disabled

false

true

HTML Optional Attribute. Setting the value of this attribute to 'true' will disable the HTML element.

element

false

true

Specifies the HTML element that is used to enclose each 'input' tag with type 'checkbox'. Defaults to 'span'.

htmlEscape

false

true

Enable/disable HTML escaping of rendered values.

id

false

true

HTML Standard Attribute

itemLabel

false

true

Value to be displayed as part of the 'input' tags with type 'checkbox'

items

true

true

The Collection, Map or array of objects used to generate the 'input' tags with type 'checkbox'

itemValue

false

true

Name of the property mapped to 'value' attribute of the 'input' tags with type 'checkbox'

lang

false

true

HTML Standard Attribute

onblur

false

true

HTML Event Attribute

onchange

false

true

HTML Event Attribute

onclick

false

true

HTML Event Attribute

ondblclick

false

true

HTML Event Attribute

onfocus

false

true

HTML Event Attribute

onkeydown

false

true

HTML Event Attribute

onkeypress

false

true

HTML Event Attribute

onkeyup

false

true

HTML Event Attribute

onmousedown

false

true

HTML Event Attribute

onmousemove

false

true

HTML Event Attribute

onmouseout

false

true

HTML Event Attribute

onmouseover

false

true

HTML Event Attribute

onmouseup

false

true

HTML Event Attribute

path

true

true

Path to property for data binding

tabindex

false

true

HTML Standard Attribute

title

false

true

HTML Standard Attribute

44.5 The errors tag

Renders field errors in an HTML 'span' tag.

Table 44.4. Attributes

Attribute Required? Runtime Expression? Description

cssClass

false

true

Equivalent to "class" - HTML Optional Attribute

cssStyle

false

true

Equivalent to "style" - HTML Optional Attribute

delimiter

false

true

Delimiter for displaying multiple error messages. Defaults to the br tag.

dir

false

true

HTML Standard Attribute

element

false

true

Specifies the HTML element that is used to render the enclosing errors.

htmlEscape

false

true

Enable/disable HTML escaping of rendered values.

id

false

true

HTML Standard Attribute

lang

false

true

HTML Standard Attribute

onclick

false

true

HTML Event Attribute

ondblclick

false

true

HTML Event Attribute

onkeydown

false

true

HTML Event Attribute

onkeypress

false

true

HTML Event Attribute

onkeyup

false

true

HTML Event Attribute

onmousedown

false

true

HTML Event Attribute

onmousemove

false

true

HTML Event Attribute

onmouseout

false

true

HTML Event Attribute

onmouseover

false

true

HTML Event Attribute

onmouseup

false

true

HTML Event Attribute

path

false

true

Path to errors object for data binding

tabindex

false

true

HTML Standard Attribute

title

false

true

HTML Standard Attribute

44.6 The form tag

Renders an HTML 'form' tag and exposes a binding path to inner tags for binding.

Table 44.5. Attributes

Attribute Required? Runtime Expression? Description

acceptCharset

false

true

Specifies the list of character encodings for input data that is accepted by the server processing this form. The value is a space- and/or comma-delimited list of charset values. The client must interpret this list as an exclusive-or list, i.e., the server is able to accept any single character encoding per entity received.

action

false

true

HTML Required Attribute

cssClass

false

true

Equivalent to "class" - HTML Optional Attribute

cssStyle

false

true

Equivalent to "style" - HTML Optional Attribute

dir

false

true

HTML Standard Attribute

enctype

false

true

HTML Optional Attribute

htmlEscape

false

true

Enable/disable HTML escaping of rendered values.

id

false

true

HTML Standard Attribute

lang

false

true

HTML Standard Attribute

method

false

true

HTML Optional Attribute

methodParam

false

true

The parameter name used for HTTP methods other then GET and POST. Default is '_method'.

modelAttribute

false

true

Name of the model attribute under which the form object is exposed. Defaults to 'command'.

name

false

true

HTML Standard Attribute - added for backwards compatibility cases

onclick

false

true

HTML Event Attribute

ondblclick

false

true

HTML Event Attribute

onkeydown

false

true

HTML Event Attribute

onkeypress

false

true

HTML Event Attribute

onkeyup

false

true

HTML Event Attribute

onmousedown

false

true

HTML Event Attribute

onmousemove

false

true

HTML Event Attribute

onmouseout

false

true

HTML Event Attribute

onmouseover

false

true

HTML Event Attribute

onmouseup

false

true

HTML Event Attribute

onreset

false

true

HTML Event Attribute

onsubmit

false

true

HTML Event Attribute

servletRelativeAction

false

true

Action reference to be appended to the current servlet path

target

false

true

HTML Optional Attribute

title

false

true

HTML Standard Attribute

44.7 The hidden tag

Renders an HTML 'input' tag with type 'hidden' using the bound value.

Table 44.6. Attributes

Attribute Required? Runtime Expression? Description

htmlEscape

false

true

Enable/disable HTML escaping of rendered values.

id

false

true

HTML Standard Attribute

path

true

true

Path to property for data binding

44.8 The input tag

Renders an HTML 'input' tag with type 'text' using the bound value.

Table 44.7. Attributes

Attribute Required? Runtime Expression? Description

accesskey

false

true

HTML Standard Attribute

alt

false

true

HTML Optional Attribute

autocomplete

false

true

Common Optional Attribute

cssClass

false

true

Equivalent to "class" - HTML Optional Attribute

cssErrorClass

false

true

Equivalent to "class" - HTML Optional Attribute. Used when the bound field has errors.

cssStyle

false

true

Equivalent to "style" - HTML Optional Attribute

dir

false

true

HTML Standard Attribute

disabled

false

true

HTML Optional Attribute. Setting the value of this attribute to 'true' will disable the HTML element.

htmlEscape

false

true

Enable/disable HTML escaping of rendered values.

id

false

true

HTML Standard Attribute

lang

false

true

HTML Standard Attribute

maxlength

false

true

HTML Optional Attribute

onblur

false

true

HTML Event Attribute

onchange

false

true

HTML Event Attribute

onclick

false

true

HTML Event Attribute

ondblclick

false

true

HTML Event Attribute

onfocus

false

true

HTML Event Attribute

onkeydown

false

true

HTML Event Attribute

onkeypress

false

true

HTML Event Attribute

onkeyup

false

true

HTML Event Attribute

onmousedown

false

true

HTML Event Attribute

onmousemove

false

true

HTML Event Attribute

onmouseout

false

true

HTML Event Attribute

onmouseover

false

true

HTML Event Attribute

onmouseup

false

true

HTML Event Attribute

onselect

false

true

HTML Event Attribute

path

true

true

Path to property for data binding

readonly

false

true

HTML Optional Attribute. Setting the value of this attribute to 'true' will make the HTML element readonly.

size

false

true

HTML Optional Attribute

tabindex

false

true

HTML Standard Attribute

title

false

true

HTML Standard Attribute

44.9 The label tag

Renders a form field label in an HTML 'label' tag.

Table 44.8. Attributes

Attribute Required? Runtime Expression? Description

cssClass

false

true

Equivalent to "class" - HTML Optional Attribute.

cssErrorClass

false

true

Equivalent to "class" - HTML Optional Attribute. Used only when errors are present.

cssStyle

false

true

Equivalent to "style" - HTML Optional Attribute

dir

false

true

HTML Standard Attribute

for

false

true

HTML Standard Attribute

htmlEscape

false

true

Enable/disable HTML escaping of rendered values.

id

false

true

HTML Standard Attribute

lang

false

true

HTML Standard Attribute

onclick

false

true

HTML Event Attribute

ondblclick

false

true

HTML Event Attribute

onkeydown

false

true

HTML Event Attribute

onkeypress

false

true

HTML Event Attribute

onkeyup

false

true

HTML Event Attribute

onmousedown

false

true

HTML Event Attribute

onmousemove

false

true

HTML Event Attribute

onmouseout

false

true

HTML Event Attribute

onmouseover

false

true

HTML Event Attribute

onmouseup

false

true

HTML Event Attribute

path

true

true

Path to errors object for data binding

tabindex

false

true

HTML Standard Attribute

title

false

true

HTML Standard Attribute

44.10 The option tag

Renders a single HTML 'option'. Sets 'selected' as appropriate based on bound value.

Table 44.9. Attributes

Attribute Required? Runtime Expression? Description

cssClass

false

true

Equivalent to "class" - HTML Optional Attribute

cssErrorClass

false

true

Equivalent to "class" - HTML Optional Attribute. Used when the bound field has errors.

cssStyle

false

true

Equivalent to "style" - HTML Optional Attribute

dir

false

true

HTML Standard Attribute

disabled

false

true

HTML Optional Attribute. Setting the value of this attribute to 'true' will disable the HTML element.

htmlEscape

false

true

Enable/disable HTML escaping of rendered values.

id

false

true

HTML Standard Attribute

label

false

true

HTML Optional Attribute

lang

false

true

HTML Standard Attribute

onclick

false

true

HTML Event Attribute

ondblclick

false

true

HTML Event Attribute

onkeydown

false

true

HTML Event Attribute

onkeypress

false

true

HTML Event Attribute

onkeyup

false

true

HTML Event Attribute

onmousedown

false

true

HTML Event Attribute

onmousemove

false

true

HTML Event Attribute

onmouseout

false

true

HTML Event Attribute

onmouseover

false

true

HTML Event Attribute

onmouseup

false

true

HTML Event Attribute

tabindex

false

true

HTML Standard Attribute

title

false

true

HTML Standard Attribute

value

true

true

HTML Optional Attribute

44.11 The options tag

Renders a list of HTML 'option' tags. Sets 'selected' as appropriate based on bound value.

Table 44.10. Attributes

Attribute Required? Runtime Expression? Description

cssClass

false

true

Equivalent to "class" - HTML Optional Attribute

cssErrorClass

false

true

Equivalent to "class" - HTML Optional Attribute. Used when the bound field has errors.

cssStyle

false

true

Equivalent to "style" - HTML Optional Attribute

dir

false

true

HTML Standard Attribute

disabled

false

true

HTML Optional Attribute. Setting the value of this attribute to 'true' will disable the HTML element.

htmlEscape

false

true

Enable/disable HTML escaping of rendered values.

id

false

true

HTML Standard Attribute

itemLabel

false

true

Name of the property mapped to the inner text of the 'option' tag

items

true

true

The Collection, Map or array of objects used to generate the inner 'option' tags

itemValue

false

true

Name of the property mapped to 'value' attribute of the 'option' tag

lang

false

true

HTML Standard Attribute

onclick

false

true

HTML Event Attribute

ondblclick

false

true

HTML Event Attribute

onkeydown

false

true

HTML Event Attribute

onkeypress

false

true

HTML Event Attribute

onkeyup

false

true

HTML Event Attribute

onmousedown

false

true

HTML Event Attribute

onmousemove

false

true

HTML Event Attribute

onmouseout

false

true

HTML Event Attribute

onmouseover

false

true

HTML Event Attribute

onmouseup

false

true

HTML Event Attribute

tabindex

false

true

HTML Standard Attribute

title

false

true

HTML Standard Attribute

44.12 The password tag

Renders an HTML 'input' tag with type 'password' using the bound value.

Table 44.11. Attributes

Attribute Required? Runtime Expression? Description

accesskey

false

true

HTML Standard Attribute

alt

false

true

HTML Optional Attribute

autocomplete

false

true

Common Optional Attribute

cssClass

false

true

Equivalent to "class" - HTML Optional Attribute

cssErrorClass

false

true

Equivalent to "class" - HTML Optional Attribute. Used when the bound field has errors.

cssStyle

false

true

Equivalent to "style" - HTML Optional Attribute

dir

false

true

HTML Standard Attribute

disabled

false

true

HTML Optional Attribute. Setting the value of this attribute to 'true' will disable the HTML element.

htmlEscape

false

true

Enable/disable HTML escaping of rendered values.

id

false

true

HTML Standard Attribute

lang

false

true

HTML Standard Attribute

maxlength

false

true

HTML Optional Attribute

onblur

false

true

HTML Event Attribute

onchange

false

true

HTML Event Attribute

onclick

false

true

HTML Event Attribute

ondblclick

false

true

HTML Event Attribute

onfocus

false

true

HTML Event Attribute

onkeydown

false

true

HTML Event Attribute

onkeypress

false

true

HTML Event Attribute

onkeyup

false

true

HTML Event Attribute

onmousedown

false

true

HTML Event Attribute

onmousemove

false

true

HTML Event Attribute

onmouseout

false

true

HTML Event Attribute

onmouseover

false

true

HTML Event Attribute

onmouseup

false

true

HTML Event Attribute

onselect

false

true

HTML Event Attribute

path

true

true

Path to property for data binding

readonly

false

true

HTML Optional Attribute. Setting the value of this attribute to 'true' will make the HTML element readonly.

showPassword

false

true

Is the password value to be shown? Defaults to false.

size

false

true

HTML Optional Attribute

tabindex

false

true

HTML Standard Attribute

title

false

true

HTML Standard Attribute

44.13 The radiobutton tag

Renders an HTML 'input' tag with type 'radio'.

Table 44.12. Attributes

Attribute Required? Runtime Expression? Description

accesskey

false

true

HTML Standard Attribute

cssClass

false

true

Equivalent to "class" - HTML Optional Attribute

cssErrorClass

false

true

Equivalent to "class" - HTML Optional Attribute. Used when the bound field has errors.

cssStyle

false

true

Equivalent to "style" - HTML Optional Attribute

dir

false

true

HTML Standard Attribute

disabled

false

true

HTML Optional Attribute. Setting the value of this attribute to 'true' will disable the HTML element.

htmlEscape

false

true

Enable/disable HTML escaping of rendered values.

id

false

true

HTML Standard Attribute

label

false

true

Value to be displayed as part of the tag

lang

false

true

HTML Standard Attribute

onblur

false

true

HTML Event Attribute

onchange

false

true

HTML Event Attribute

onclick

false

true

HTML Event Attribute

ondblclick

false

true

HTML Event Attribute

onfocus

false

true

HTML Event Attribute

onkeydown

false

true

HTML Event Attribute

onkeypress

false

true

HTML Event Attribute

onkeyup

false

true

HTML Event Attribute

onmousedown

false

true

HTML Event Attribute

onmousemove

false

true

HTML Event Attribute

onmouseout

false

true

HTML Event Attribute

onmouseover

false

true

HTML Event Attribute

onmouseup

false

true

HTML Event Attribute

path

true

true

Path to property for data binding

tabindex

false

true

HTML Standard Attribute

title

false

true

HTML Standard Attribute

value

false

true

HTML Optional Attribute

44.14 The radiobuttons tag

Renders multiple HTML 'input' tags with type 'radio'.

Table 44.13. Attributes

Attribute Required? Runtime Expression? Description

accesskey

false

true

HTML Standard Attribute

cssClass

false

true

Equivalent to "class" - HTML Optional Attribute

cssErrorClass

false

true

Equivalent to "class" - HTML Optional Attribute. Used when the bound field has errors.

cssStyle

false

true

Equivalent to "style" - HTML Optional Attribute

delimiter

false

true

Delimiter to use between each 'input' tag with type 'radio'. There is no delimiter by default.

dir

false

true

HTML Standard Attribute

disabled

false

true

HTML Optional Attribute. Setting the value of this attribute to 'true' will disable the HTML element.

element

false

true

Specifies the HTML element that is used to enclose each 'input' tag with type 'radio'. Defaults to 'span'.

htmlEscape

false

true

Enable/disable HTML escaping of rendered values.

id

false

true

HTML Standard Attribute

itemLabel

false

true

Value to be displayed as part of the 'input' tags with type 'radio'

items

true

true

The Collection, Map or array of objects used to generate the 'input' tags with type 'radio'

itemValue

false

true

Name of the property mapped to 'value' attribute of the 'input' tags with type 'radio'

lang

false

true

HTML Standard Attribute

onblur

false

true

HTML Event Attribute

onchange

false

true

HTML Event Attribute

onclick

false

true

HTML Event Attribute

ondblclick

false

true

HTML Event Attribute

onfocus

false

true

HTML Event Attribute

onkeydown

false

true

HTML Event Attribute

onkeypress

false

true

HTML Event Attribute

onkeyup

false

true

HTML Event Attribute

onmousedown

false

true

HTML Event Attribute

onmousemove

false

true

HTML Event Attribute

onmouseout

false

true

HTML Event Attribute

onmouseover

false

true

HTML Event Attribute

onmouseup

false

true

HTML Event Attribute

path

true

true

Path to property for data binding

tabindex

false

true

HTML Standard Attribute

title

false

true

HTML Standard Attribute

44.15 The select tag

Renders an HTML 'select' element. Supports databinding to the selected option.

Table 44.14. Attributes

Attribute Required? Runtime Expression? Description

accesskey

false

true

HTML Standard Attribute

cssClass

false

true

Equivalent to "class" - HTML Optional Attribute

cssErrorClass

false

true

Equivalent to "class" - HTML Optional Attribute. Used when the bound field has errors.

cssStyle

false

true

Equivalent to "style" - HTML Optional Attribute

dir

false

true

HTML Standard Attribute

disabled

false

true

HTML Optional Attribute. Setting the value of this attribute to 'true' will disable the HTML element.

htmlEscape

false

true

Enable/disable HTML escaping of rendered values.

id

false

true

HTML Standard Attribute

itemLabel

false

true

Name of the property mapped to the inner text of the 'option' tag

items

false

true

The Collection, Map or array of objects used to generate the inner 'option' tags

itemValue

false

true

Name of the property mapped to 'value' attribute of the 'option' tag

lang

false

true

HTML Standard Attribute

multiple

false

true

HTML Optional Attribute

onblur

false

true

HTML Event Attribute

onchange

false

true

HTML Event Attribute

onclick

false

true

HTML Event Attribute

ondblclick

false

true

HTML Event Attribute

onfocus

false

true

HTML Event Attribute

onkeydown

false

true

HTML Event Attribute

onkeypress

false

true

HTML Event Attribute

onkeyup

false

true

HTML Event Attribute

onmousedown

false

true

HTML Event Attribute

onmousemove

false

true

HTML Event Attribute

onmouseout

false

true

HTML Event Attribute

onmouseover

false

true

HTML Event Attribute

onmouseup

false

true

HTML Event Attribute

path

true

true

Path to property for data binding

size

false

true

HTML Optional Attribute

tabindex

false

true

HTML Standard Attribute

title

false

true

HTML Standard Attribute

44.16 The textarea tag

Renders an HTML 'textarea'.

Table 44.15. Attributes

Attribute Required? Runtime Expression? Description

accesskey

false

true

HTML Standard Attribute

cols

false

true

HTML Required Attribute

cssClass

false

true

Equivalent to "class" - HTML Optional Attribute

cssErrorClass

false

true

Equivalent to "class" - HTML Optional Attribute. Used when the bound field has errors.

cssStyle

false

true

Equivalent to "style" - HTML Optional Attribute

dir

false

true

HTML Standard Attribute

disabled

false

true

HTML Optional Attribute. Setting the value of this attribute to 'true' will disable the HTML element.

htmlEscape

false

true

Enable/disable HTML escaping of rendered values.

id

false

true

HTML Standard Attribute

lang

false

true

HTML Standard Attribute

onblur

false

true

HTML Event Attribute

onchange

false

true

HTML Event Attribute

onclick

false

true

HTML Event Attribute

ondblclick

false

true

HTML Event Attribute

onfocus

false

true

HTML Event Attribute

onkeydown

false

true

HTML Event Attribute

onkeypress

false

true

HTML Event Attribute

onkeyup

false

true

HTML Event Attribute

onmousedown

false

true

HTML Event Attribute

onmousemove

false

true

HTML Event Attribute

onmouseout

false

true

HTML Event Attribute

onmouseover

false

true

HTML Event Attribute

onmouseup

false

true

HTML Event Attribute

onselect

false

true

HTML Event Attribute

path

true

true

Path to property for data binding

readonly

false

true

HTML Optional Attribute. Setting the value of this attribute to 'true' will make the HTML element readonly.

rows

false

true

HTML Required Attribute

tabindex

false

true

HTML Standard Attribute

title

false

true

HTML Standard Attribute